/*
 * 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.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
{
    /// <summary>
    /// Implementation for accessing EC2
    ///
    /// Amazon Elastic Compute Cloud 
    /// <para>
    /// 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.
    /// </para>
    ///  
    /// <para>
    /// To learn more, see the following resources:
    /// </para>
    ///  <ul> <li> 
    /// <para>
    /// Amazon EC2: <a href="http://aws.amazon.com/ec2">Amazon EC2 product page</a>, <a href="https://docs.aws.amazon.com/ec2/index.html">Amazon
    /// EC2 documentation</a> 
    /// </para>
    ///  </li> <li> 
    /// <para>
    /// Amazon EBS: <a href="http://aws.amazon.com/ebs">Amazon EBS product page</a>, <a href="https://docs.aws.amazon.com/ebs/index.html">Amazon
    /// EBS documentation</a> 
    /// </para>
    ///  </li> <li> 
    /// <para>
    /// Amazon VPC: <a href="http://aws.amazon.com/vpc">Amazon VPC product page</a>, <a href="https://docs.aws.amazon.com/vpc/index.html">Amazon
    /// VPC documentation</a> 
    /// </para>
    ///  </li> <li> 
    /// <para>
    /// VPN: <a href="http://aws.amazon.com/vpn">VPN product page</a>, <a href="https://docs.aws.amazon.com/vpn/index.html">VPN
    /// documentation</a> 
    /// </para>
    ///  </li> </ul>
    /// </summary>
    public partial class AmazonEC2Client : AmazonServiceClient, IAmazonEC2
    {
        private static IServiceMetadata serviceMetadata = new AmazonEC2Metadata();

#if BCL45 || AWS_ASYNC_ENUMERABLES_API
        private IEC2PaginatorFactory _paginators;

        /// <summary>
        /// Paginators for the service
        /// </summary>
        public IEC2PaginatorFactory Paginators 
        {
            get 
            {
                if (this._paginators == null) 
                {
                    this._paginators = new EC2PaginatorFactory(this);
                }
                return this._paginators;
            }
        }
#endif
        #region Constructors

        /// <summary>
        /// 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. 
        /// <code>
        /// &lt;?xml version="1.0" encoding="utf-8" ?&gt;
        /// &lt;configuration&gt;
        ///     &lt;appSettings&gt;
        ///         &lt;add key="AWSProfileName" value="AWS Default"/&gt;
        ///     &lt;/appSettings&gt;
        /// &lt;/configuration&gt;
        /// </code>
        ///
        /// </summary>
        public AmazonEC2Client()
            : base(FallbackCredentialsFactory.GetCredentials(), new AmazonEC2Config()) { }

        /// <summary>
        /// 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. 
        /// <code>
        /// &lt;?xml version="1.0" encoding="utf-8" ?&gt;
        /// &lt;configuration&gt;
        ///     &lt;appSettings&gt;
        ///         &lt;add key="AWSProfileName" value="AWS Default"/&gt;
        ///     &lt;/appSettings&gt;
        /// &lt;/configuration&gt;
        /// </code>
        ///
        /// </summary>
        /// <param name="region">The region to connect.</param>
        public AmazonEC2Client(RegionEndpoint region)
            : base(FallbackCredentialsFactory.GetCredentials(), new AmazonEC2Config{RegionEndpoint = region}) { }

        /// <summary>
        /// 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. 
        /// <code>
        /// &lt;?xml version="1.0" encoding="utf-8" ?&gt;
        /// &lt;configuration&gt;
        ///     &lt;appSettings&gt;
        ///         &lt;add key="AWSProfileName" value="AWS Default"/&gt;
        ///     &lt;/appSettings&gt;
        /// &lt;/configuration&gt;
        /// </code>
        ///
        /// </summary>
        /// <param name="config">The AmazonEC2Client Configuration Object</param>
        public AmazonEC2Client(AmazonEC2Config config)
            : base(FallbackCredentialsFactory.GetCredentials(config), config){}
        /// <summary>
        /// Constructs AmazonEC2Client with AWS Credentials
        /// </summary>
        /// <param name="credentials">AWS Credentials</param>
        public AmazonEC2Client(AWSCredentials credentials)
            : this(credentials, new AmazonEC2Config())
        {
        }

        /// <summary>
        /// Constructs AmazonEC2Client with AWS Credentials
        /// </summary>
        /// <param name="credentials">AWS Credentials</param>
        /// <param name="region">The region to connect.</param>
        public AmazonEC2Client(AWSCredentials credentials, RegionEndpoint region)
            : this(credentials, new AmazonEC2Config{RegionEndpoint = region})
        {
        }

        /// <summary>
        /// Constructs AmazonEC2Client with AWS Credentials and an
        /// AmazonEC2Client Configuration object.
        /// </summary>
        /// <param name="credentials">AWS Credentials</param>
        /// <param name="clientConfig">The AmazonEC2Client Configuration Object</param>
        public AmazonEC2Client(AWSCredentials credentials, AmazonEC2Config clientConfig)
            : base(credentials, clientConfig)
        {
        }

        /// <summary>
        /// Constructs AmazonEC2Client with AWS Access Key ID and AWS Secret Key
        /// </summary>
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonEC2Config())
        {
        }

        /// <summary>
        /// Constructs AmazonEC2Client with AWS Access Key ID and AWS Secret Key
        /// </summary>
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="region">The region to connect.</param>
        public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, new AmazonEC2Config() {RegionEndpoint=region})
        {
        }

        /// <summary>
        /// Constructs AmazonEC2Client with AWS Access Key ID, AWS Secret Key and an
        /// AmazonEC2Client Configuration object. 
        /// </summary>
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="clientConfig">The AmazonEC2Client Configuration Object</param>
        public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, AmazonEC2Config clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, clientConfig)
        {
        }

        /// <summary>
        /// Constructs AmazonEC2Client with AWS Access Key ID and AWS Secret Key
        /// </summary>
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="awsSessionToken">AWS Session Token</param>
        public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonEC2Config())
        {
        }

        /// <summary>
        /// Constructs AmazonEC2Client with AWS Access Key ID and AWS Secret Key
        /// </summary>
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="awsSessionToken">AWS Session Token</param>
        /// <param name="region">The region to connect.</param>
        public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region)
            : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonEC2Config{RegionEndpoint = region})
        {
        }

        /// <summary>
        /// Constructs AmazonEC2Client with AWS Access Key ID, AWS Secret Key and an
        /// AmazonEC2Client Configuration object. 
        /// </summary>
        /// <param name="awsAccessKeyId">AWS Access Key ID</param>
        /// <param name="awsSecretAccessKey">AWS Secret Access Key</param>
        /// <param name="awsSessionToken">AWS Session Token</param>
        /// <param name="clientConfig">The AmazonEC2Client Configuration Object</param>
        public AmazonEC2Client(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonEC2Config clientConfig)
            : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig)
        {
        }

        #endregion

        #region Overrides

        
        /// <summary>
        /// Creates the signer for the service.
        /// </summary>
        protected override AbstractAWSSigner CreateSigner()
        {
            return new AWS4Signer();
        }

        /// <summary>
        /// Customize the pipeline
        /// </summary>
        /// <param name="pipeline"></param>
        protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline)
        {
            pipeline.AddHandlerBefore<Amazon.Runtime.Internal.Marshaller>(new Amazon.EC2.Internal.AmazonEC2PreMarshallHandler(this.Credentials));
            pipeline.AddHandlerAfter<Amazon.Runtime.Internal.Marshaller>(new Amazon.EC2.Internal.AmazonEC2PostMarshallHandler());
            pipeline.AddHandlerBefore<Amazon.Runtime.Internal.Unmarshaller>(new Amazon.EC2.Internal.AmazonEC2ResponseHandler());
            if(this.Config.RetryMode == RequestRetryMode.Legacy)
            {
                pipeline.ReplaceHandler<Amazon.Runtime.Internal.RetryHandler>(new Amazon.Runtime.Internal.RetryHandler(new Amazon.EC2.Internal.EC2RetryPolicy(this.Config)));
            }
            if(this.Config.RetryMode == RequestRetryMode.Standard)
            {
                pipeline.ReplaceHandler<Amazon.Runtime.Internal.RetryHandler>(new Amazon.Runtime.Internal.RetryHandler(new Amazon.EC2.Internal.EC2StandardRetryPolicy(this.Config)));
            }
            if(this.Config.RetryMode == RequestRetryMode.Adaptive)
            {
                pipeline.ReplaceHandler<Amazon.Runtime.Internal.RetryHandler>(new Amazon.Runtime.Internal.RetryHandler(new Amazon.EC2.Internal.EC2AdaptiveRetryPolicy(this.Config)));
            }
            pipeline.RemoveHandler<Amazon.Runtime.Internal.EndpointResolver>();
            pipeline.AddHandlerAfter<Amazon.Runtime.Internal.Marshaller>(new AmazonEC2EndpointResolver());
        }
        /// <summary>
        /// Capture metadata for the service.
        /// </summary>
        protected override IServiceMetadata ServiceMetadata
        {
            get
            {
                return serviceMetadata;
            }
        }

        #endregion

        #region Dispose

        /// <summary>
        /// Disposes the service client.
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

        #endregion


        #region  AcceptAddressTransfer

        /// <summary>
        /// Accepts an Elastic IP address transfer. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#using-instance-addressing-eips-transfer-accept">Accept
        /// a transferred Elastic IP address</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AcceptAddressTransfer service method.</param>
        /// 
        /// <returns>The response from the AcceptAddressTransfer service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptAddressTransfer">REST API Reference for AcceptAddressTransfer Operation</seealso>
        public virtual AcceptAddressTransferResponse AcceptAddressTransfer(AcceptAddressTransferRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptAddressTransferRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptAddressTransferResponseUnmarshaller.Instance;

            return Invoke<AcceptAddressTransferResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AcceptAddressTransfer operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AcceptAddressTransfer operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAcceptAddressTransfer
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptAddressTransfer">REST API Reference for AcceptAddressTransfer Operation</seealso>
        public virtual IAsyncResult BeginAcceptAddressTransfer(AcceptAddressTransferRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptAddressTransferRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptAddressTransferResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AcceptAddressTransfer operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAcceptAddressTransfer.</param>
        /// 
        /// <returns>Returns a  AcceptAddressTransferResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptAddressTransfer">REST API Reference for AcceptAddressTransfer Operation</seealso>
        public virtual AcceptAddressTransferResponse EndAcceptAddressTransfer(IAsyncResult asyncResult)
        {
            return EndInvoke<AcceptAddressTransferResponse>(asyncResult);
        }

        #endregion
        
        #region  AcceptReservedInstancesExchangeQuote

        /// <summary>
        /// Accepts the Convertible Reserved Instance exchange quote described in the <a>GetReservedInstancesExchangeQuote</a>
        /// call.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AcceptReservedInstancesExchangeQuote service method.</param>
        /// 
        /// <returns>The response from the AcceptReservedInstancesExchangeQuote service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptReservedInstancesExchangeQuote">REST API Reference for AcceptReservedInstancesExchangeQuote Operation</seealso>
        public virtual AcceptReservedInstancesExchangeQuoteResponse AcceptReservedInstancesExchangeQuote(AcceptReservedInstancesExchangeQuoteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptReservedInstancesExchangeQuoteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptReservedInstancesExchangeQuoteResponseUnmarshaller.Instance;

            return Invoke<AcceptReservedInstancesExchangeQuoteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AcceptReservedInstancesExchangeQuote operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AcceptReservedInstancesExchangeQuote operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAcceptReservedInstancesExchangeQuote
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptReservedInstancesExchangeQuote">REST API Reference for AcceptReservedInstancesExchangeQuote Operation</seealso>
        public virtual IAsyncResult BeginAcceptReservedInstancesExchangeQuote(AcceptReservedInstancesExchangeQuoteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptReservedInstancesExchangeQuoteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptReservedInstancesExchangeQuoteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AcceptReservedInstancesExchangeQuote operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAcceptReservedInstancesExchangeQuote.</param>
        /// 
        /// <returns>Returns a  AcceptReservedInstancesExchangeQuoteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptReservedInstancesExchangeQuote">REST API Reference for AcceptReservedInstancesExchangeQuote Operation</seealso>
        public virtual AcceptReservedInstancesExchangeQuoteResponse EndAcceptReservedInstancesExchangeQuote(IAsyncResult asyncResult)
        {
            return EndInvoke<AcceptReservedInstancesExchangeQuoteResponse>(asyncResult);
        }

        #endregion
        
        #region  AcceptTransitGatewayMulticastDomainAssociations

        /// <summary>
        /// Accepts a request to associate subnets with a transit gateway multicast domain.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AcceptTransitGatewayMulticastDomainAssociations service method.</param>
        /// 
        /// <returns>The response from the AcceptTransitGatewayMulticastDomainAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayMulticastDomainAssociations">REST API Reference for AcceptTransitGatewayMulticastDomainAssociations Operation</seealso>
        public virtual AcceptTransitGatewayMulticastDomainAssociationsResponse AcceptTransitGatewayMulticastDomainAssociations(AcceptTransitGatewayMulticastDomainAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance;

            return Invoke<AcceptTransitGatewayMulticastDomainAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AcceptTransitGatewayMulticastDomainAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AcceptTransitGatewayMulticastDomainAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAcceptTransitGatewayMulticastDomainAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayMulticastDomainAssociations">REST API Reference for AcceptTransitGatewayMulticastDomainAssociations Operation</seealso>
        public virtual IAsyncResult BeginAcceptTransitGatewayMulticastDomainAssociations(AcceptTransitGatewayMulticastDomainAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AcceptTransitGatewayMulticastDomainAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAcceptTransitGatewayMulticastDomainAssociations.</param>
        /// 
        /// <returns>Returns a  AcceptTransitGatewayMulticastDomainAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayMulticastDomainAssociations">REST API Reference for AcceptTransitGatewayMulticastDomainAssociations Operation</seealso>
        public virtual AcceptTransitGatewayMulticastDomainAssociationsResponse EndAcceptTransitGatewayMulticastDomainAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<AcceptTransitGatewayMulticastDomainAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  AcceptTransitGatewayPeeringAttachment

        /// <summary>
        /// Accepts a transit gateway peering attachment request. The peering attachment must
        /// be in the <code>pendingAcceptance</code> state.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AcceptTransitGatewayPeeringAttachment service method.</param>
        /// 
        /// <returns>The response from the AcceptTransitGatewayPeeringAttachment service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayPeeringAttachment">REST API Reference for AcceptTransitGatewayPeeringAttachment Operation</seealso>
        public virtual AcceptTransitGatewayPeeringAttachmentResponse AcceptTransitGatewayPeeringAttachment(AcceptTransitGatewayPeeringAttachmentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptTransitGatewayPeeringAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance;

            return Invoke<AcceptTransitGatewayPeeringAttachmentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AcceptTransitGatewayPeeringAttachment operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AcceptTransitGatewayPeeringAttachment operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAcceptTransitGatewayPeeringAttachment
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayPeeringAttachment">REST API Reference for AcceptTransitGatewayPeeringAttachment Operation</seealso>
        public virtual IAsyncResult BeginAcceptTransitGatewayPeeringAttachment(AcceptTransitGatewayPeeringAttachmentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptTransitGatewayPeeringAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AcceptTransitGatewayPeeringAttachment operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAcceptTransitGatewayPeeringAttachment.</param>
        /// 
        /// <returns>Returns a  AcceptTransitGatewayPeeringAttachmentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayPeeringAttachment">REST API Reference for AcceptTransitGatewayPeeringAttachment Operation</seealso>
        public virtual AcceptTransitGatewayPeeringAttachmentResponse EndAcceptTransitGatewayPeeringAttachment(IAsyncResult asyncResult)
        {
            return EndInvoke<AcceptTransitGatewayPeeringAttachmentResponse>(asyncResult);
        }

        #endregion
        
        #region  AcceptTransitGatewayVpcAttachment

        /// <summary>
        /// Accepts a request to attach a VPC to a transit gateway.
        /// 
        ///  
        /// <para>
        /// The VPC attachment must be in the <code>pendingAcceptance</code> state. Use <a>DescribeTransitGatewayVpcAttachments</a>
        /// to view your pending VPC attachment requests. Use <a>RejectTransitGatewayVpcAttachment</a>
        /// to reject a VPC attachment request.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AcceptTransitGatewayVpcAttachment service method.</param>
        /// 
        /// <returns>The response from the AcceptTransitGatewayVpcAttachment service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayVpcAttachment">REST API Reference for AcceptTransitGatewayVpcAttachment Operation</seealso>
        public virtual AcceptTransitGatewayVpcAttachmentResponse AcceptTransitGatewayVpcAttachment(AcceptTransitGatewayVpcAttachmentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return Invoke<AcceptTransitGatewayVpcAttachmentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AcceptTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AcceptTransitGatewayVpcAttachment operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAcceptTransitGatewayVpcAttachment
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayVpcAttachment">REST API Reference for AcceptTransitGatewayVpcAttachment Operation</seealso>
        public virtual IAsyncResult BeginAcceptTransitGatewayVpcAttachment(AcceptTransitGatewayVpcAttachmentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AcceptTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAcceptTransitGatewayVpcAttachment.</param>
        /// 
        /// <returns>Returns a  AcceptTransitGatewayVpcAttachmentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptTransitGatewayVpcAttachment">REST API Reference for AcceptTransitGatewayVpcAttachment Operation</seealso>
        public virtual AcceptTransitGatewayVpcAttachmentResponse EndAcceptTransitGatewayVpcAttachment(IAsyncResult asyncResult)
        {
            return EndInvoke<AcceptTransitGatewayVpcAttachmentResponse>(asyncResult);
        }

        #endregion
        
        #region  AcceptVpcEndpointConnections

        /// <summary>
        /// Accepts connection requests to your VPC endpoint service.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AcceptVpcEndpointConnections service method.</param>
        /// 
        /// <returns>The response from the AcceptVpcEndpointConnections service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcEndpointConnections">REST API Reference for AcceptVpcEndpointConnections Operation</seealso>
        public virtual AcceptVpcEndpointConnectionsResponse AcceptVpcEndpointConnections(AcceptVpcEndpointConnectionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptVpcEndpointConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptVpcEndpointConnectionsResponseUnmarshaller.Instance;

            return Invoke<AcceptVpcEndpointConnectionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AcceptVpcEndpointConnections operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AcceptVpcEndpointConnections operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAcceptVpcEndpointConnections
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcEndpointConnections">REST API Reference for AcceptVpcEndpointConnections Operation</seealso>
        public virtual IAsyncResult BeginAcceptVpcEndpointConnections(AcceptVpcEndpointConnectionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptVpcEndpointConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptVpcEndpointConnectionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AcceptVpcEndpointConnections operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAcceptVpcEndpointConnections.</param>
        /// 
        /// <returns>Returns a  AcceptVpcEndpointConnectionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcEndpointConnections">REST API Reference for AcceptVpcEndpointConnections Operation</seealso>
        public virtual AcceptVpcEndpointConnectionsResponse EndAcceptVpcEndpointConnections(IAsyncResult asyncResult)
        {
            return EndInvoke<AcceptVpcEndpointConnectionsResponse>(asyncResult);
        }

        #endregion
        
        #region  AcceptVpcPeeringConnection

        /// <summary>
        /// Accept a VPC peering connection request. To accept a request, the VPC peering connection
        /// must be in the <code>pending-acceptance</code> state, and you must be the owner of
        /// the peer VPC. Use <a>DescribeVpcPeeringConnections</a> to view your outstanding VPC
        /// peering connection requests.
        /// 
        ///  
        /// <para>
        /// For an inter-Region VPC peering connection request, you must accept the VPC peering
        /// connection in the Region of the accepter VPC.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AcceptVpcPeeringConnection service method.</param>
        /// 
        /// <returns>The response from the AcceptVpcPeeringConnection service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcPeeringConnection">REST API Reference for AcceptVpcPeeringConnection Operation</seealso>
        public virtual AcceptVpcPeeringConnectionResponse AcceptVpcPeeringConnection(AcceptVpcPeeringConnectionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptVpcPeeringConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptVpcPeeringConnectionResponseUnmarshaller.Instance;

            return Invoke<AcceptVpcPeeringConnectionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AcceptVpcPeeringConnection operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AcceptVpcPeeringConnection operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAcceptVpcPeeringConnection
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcPeeringConnection">REST API Reference for AcceptVpcPeeringConnection Operation</seealso>
        public virtual IAsyncResult BeginAcceptVpcPeeringConnection(AcceptVpcPeeringConnectionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AcceptVpcPeeringConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AcceptVpcPeeringConnectionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AcceptVpcPeeringConnection operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAcceptVpcPeeringConnection.</param>
        /// 
        /// <returns>Returns a  AcceptVpcPeeringConnectionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AcceptVpcPeeringConnection">REST API Reference for AcceptVpcPeeringConnection Operation</seealso>
        public virtual AcceptVpcPeeringConnectionResponse EndAcceptVpcPeeringConnection(IAsyncResult asyncResult)
        {
            return EndInvoke<AcceptVpcPeeringConnectionResponse>(asyncResult);
        }

        #endregion
        
        #region  AdvertiseByoipCidr

        /// <summary>
        /// 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).
        /// 
        ///  
        /// <para>
        /// You can perform this operation at most once every 10 seconds, even if you specify
        /// different address ranges each time.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// It can take a few minutes before traffic to the specified addresses starts routing
        /// to Amazon Web Services because of BGP propagation delays.
        /// </para>
        ///  
        /// <para>
        /// To stop advertising the BYOIP CIDR, use <a>WithdrawByoipCidr</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AdvertiseByoipCidr service method.</param>
        /// 
        /// <returns>The response from the AdvertiseByoipCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AdvertiseByoipCidr">REST API Reference for AdvertiseByoipCidr Operation</seealso>
        public virtual AdvertiseByoipCidrResponse AdvertiseByoipCidr(AdvertiseByoipCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AdvertiseByoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AdvertiseByoipCidrResponseUnmarshaller.Instance;

            return Invoke<AdvertiseByoipCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AdvertiseByoipCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AdvertiseByoipCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAdvertiseByoipCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AdvertiseByoipCidr">REST API Reference for AdvertiseByoipCidr Operation</seealso>
        public virtual IAsyncResult BeginAdvertiseByoipCidr(AdvertiseByoipCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AdvertiseByoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AdvertiseByoipCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AdvertiseByoipCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAdvertiseByoipCidr.</param>
        /// 
        /// <returns>Returns a  AdvertiseByoipCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AdvertiseByoipCidr">REST API Reference for AdvertiseByoipCidr Operation</seealso>
        public virtual AdvertiseByoipCidrResponse EndAdvertiseByoipCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<AdvertiseByoipCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  AllocateAddress

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">Bring
        /// Your Own IP Addresses (BYOIP)</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html">Elastic
        /// IP Addresses</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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).
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the AllocateAddress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateAddress">REST API Reference for AllocateAddress Operation</seealso>
        public virtual AllocateAddressResponse AllocateAddress()
        {
            return AllocateAddress(new AllocateAddressRequest());
        }

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">Bring
        /// Your Own IP Addresses (BYOIP)</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html">Elastic
        /// IP Addresses</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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).
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AllocateAddress service method.</param>
        /// 
        /// <returns>The response from the AllocateAddress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateAddress">REST API Reference for AllocateAddress Operation</seealso>
        public virtual AllocateAddressResponse AllocateAddress(AllocateAddressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AllocateAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AllocateAddressResponseUnmarshaller.Instance;

            return Invoke<AllocateAddressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AllocateAddress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AllocateAddress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAllocateAddress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateAddress">REST API Reference for AllocateAddress Operation</seealso>
        public virtual IAsyncResult BeginAllocateAddress(AllocateAddressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AllocateAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AllocateAddressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AllocateAddress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAllocateAddress.</param>
        /// 
        /// <returns>Returns a  AllocateAddressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateAddress">REST API Reference for AllocateAddress Operation</seealso>
        public virtual AllocateAddressResponse EndAllocateAddress(IAsyncResult asyncResult)
        {
            return EndInvoke<AllocateAddressResponse>(asyncResult);
        }

        #endregion
        
        #region  AllocateHosts

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AllocateHosts service method.</param>
        /// 
        /// <returns>The response from the AllocateHosts service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateHosts">REST API Reference for AllocateHosts Operation</seealso>
        public virtual AllocateHostsResponse AllocateHosts(AllocateHostsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AllocateHostsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AllocateHostsResponseUnmarshaller.Instance;

            return Invoke<AllocateHostsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AllocateHosts operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AllocateHosts operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAllocateHosts
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateHosts">REST API Reference for AllocateHosts Operation</seealso>
        public virtual IAsyncResult BeginAllocateHosts(AllocateHostsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AllocateHostsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AllocateHostsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AllocateHosts operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAllocateHosts.</param>
        /// 
        /// <returns>Returns a  AllocateHostsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateHosts">REST API Reference for AllocateHosts Operation</seealso>
        public virtual AllocateHostsResponse EndAllocateHosts(IAsyncResult asyncResult)
        {
            return EndInvoke<AllocateHostsResponse>(asyncResult);
        }

        #endregion
        
        #region  AllocateIpamPoolCidr

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// In IPAM, an allocation is a CIDR assignment from an IPAM pool to another IPAM pool
        /// or to a resource. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/allocate-cidrs-ipam.html">Allocate
        /// CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.
        /// </para>
        ///  <note> 
        /// <para>
        /// This action creates an allocation with strong consistency. The returned CIDR will
        /// not overlap with any other allocations from the same pool.
        /// </para>
        ///  </note>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AllocateIpamPoolCidr service method.</param>
        /// 
        /// <returns>The response from the AllocateIpamPoolCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateIpamPoolCidr">REST API Reference for AllocateIpamPoolCidr Operation</seealso>
        public virtual AllocateIpamPoolCidrResponse AllocateIpamPoolCidr(AllocateIpamPoolCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AllocateIpamPoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AllocateIpamPoolCidrResponseUnmarshaller.Instance;

            return Invoke<AllocateIpamPoolCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AllocateIpamPoolCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AllocateIpamPoolCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAllocateIpamPoolCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateIpamPoolCidr">REST API Reference for AllocateIpamPoolCidr Operation</seealso>
        public virtual IAsyncResult BeginAllocateIpamPoolCidr(AllocateIpamPoolCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AllocateIpamPoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AllocateIpamPoolCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AllocateIpamPoolCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAllocateIpamPoolCidr.</param>
        /// 
        /// <returns>Returns a  AllocateIpamPoolCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AllocateIpamPoolCidr">REST API Reference for AllocateIpamPoolCidr Operation</seealso>
        public virtual AllocateIpamPoolCidrResponse EndAllocateIpamPoolCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<AllocateIpamPoolCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  ApplySecurityGroupsToClientVpnTargetNetwork

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ApplySecurityGroupsToClientVpnTargetNetwork service method.</param>
        /// 
        /// <returns>The response from the ApplySecurityGroupsToClientVpnTargetNetwork service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ApplySecurityGroupsToClientVpnTargetNetwork">REST API Reference for ApplySecurityGroupsToClientVpnTargetNetwork Operation</seealso>
        public virtual ApplySecurityGroupsToClientVpnTargetNetworkResponse ApplySecurityGroupsToClientVpnTargetNetwork(ApplySecurityGroupsToClientVpnTargetNetworkRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ApplySecurityGroupsToClientVpnTargetNetworkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ApplySecurityGroupsToClientVpnTargetNetworkResponseUnmarshaller.Instance;

            return Invoke<ApplySecurityGroupsToClientVpnTargetNetworkResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ApplySecurityGroupsToClientVpnTargetNetwork operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ApplySecurityGroupsToClientVpnTargetNetwork operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndApplySecurityGroupsToClientVpnTargetNetwork
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ApplySecurityGroupsToClientVpnTargetNetwork">REST API Reference for ApplySecurityGroupsToClientVpnTargetNetwork Operation</seealso>
        public virtual IAsyncResult BeginApplySecurityGroupsToClientVpnTargetNetwork(ApplySecurityGroupsToClientVpnTargetNetworkRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ApplySecurityGroupsToClientVpnTargetNetworkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ApplySecurityGroupsToClientVpnTargetNetworkResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ApplySecurityGroupsToClientVpnTargetNetwork operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginApplySecurityGroupsToClientVpnTargetNetwork.</param>
        /// 
        /// <returns>Returns a  ApplySecurityGroupsToClientVpnTargetNetworkResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ApplySecurityGroupsToClientVpnTargetNetwork">REST API Reference for ApplySecurityGroupsToClientVpnTargetNetwork Operation</seealso>
        public virtual ApplySecurityGroupsToClientVpnTargetNetworkResponse EndApplySecurityGroupsToClientVpnTargetNetwork(IAsyncResult asyncResult)
        {
            return EndInvoke<ApplySecurityGroupsToClientVpnTargetNetworkResponse>(asyncResult);
        }

        #endregion
        
        #region  AssignIpv6Addresses

        /// <summary>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI">IP
        /// Addresses Per Network Interface Per Instance Type</a> in the <i>Amazon Elastic Compute
        /// Cloud User Guide</i>.
        /// 
        ///  
        /// <para>
        /// You must specify either the IPv6 addresses or the IPv6 address count in the request.
        /// 
        /// </para>
        ///  
        /// <para>
        /// You can optionally use Prefix Delegation on the network interface. You must specify
        /// either the IPV6 Prefix Delegation prefixes, or the IPv6 Prefix Delegation count. For
        /// information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html">
        /// Assigning prefixes to Amazon EC2 network interfaces</a> in the <i>Amazon Elastic Compute
        /// Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssignIpv6Addresses service method.</param>
        /// 
        /// <returns>The response from the AssignIpv6Addresses service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignIpv6Addresses">REST API Reference for AssignIpv6Addresses Operation</seealso>
        public virtual AssignIpv6AddressesResponse AssignIpv6Addresses(AssignIpv6AddressesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssignIpv6AddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssignIpv6AddressesResponseUnmarshaller.Instance;

            return Invoke<AssignIpv6AddressesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssignIpv6Addresses operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssignIpv6Addresses operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssignIpv6Addresses
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignIpv6Addresses">REST API Reference for AssignIpv6Addresses Operation</seealso>
        public virtual IAsyncResult BeginAssignIpv6Addresses(AssignIpv6AddressesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssignIpv6AddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssignIpv6AddressesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssignIpv6Addresses operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssignIpv6Addresses.</param>
        /// 
        /// <returns>Returns a  AssignIpv6AddressesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignIpv6Addresses">REST API Reference for AssignIpv6Addresses Operation</seealso>
        public virtual AssignIpv6AddressesResponse EndAssignIpv6Addresses(IAsyncResult asyncResult)
        {
            return EndInvoke<AssignIpv6AddressesResponse>(asyncResult);
        }

        #endregion
        
        #region  AssignPrivateIpAddresses

        /// <summary>
        /// Assigns one or more secondary private IP addresses to the specified network interface.
        /// 
        ///  
        /// <para>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html">Instance
        /// Types</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. For more information
        /// about Elastic IP addresses, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html">Elastic
        /// IP Addresses</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// Remapping an IP address is an asynchronous operation. When you move an IP address
        /// from one network interface to another, check <code>network/interfaces/macs/mac/local-ipv4s</code>
        /// in the instance metadata to confirm that the remapping is complete.
        /// </para>
        ///  
        /// <para>
        /// You must specify either the IP addresses or the IP address count in the request.
        /// </para>
        ///  
        /// <para>
        /// You can optionally use Prefix Delegation on the network interface. You must specify
        /// either the IPv4 Prefix Delegation prefixes, or the IPv4 Prefix Delegation count. For
        /// information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-prefix-eni.html">
        /// Assigning prefixes to Amazon EC2 network interfaces</a> in the <i>Amazon Elastic Compute
        /// Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssignPrivateIpAddresses service method.</param>
        /// 
        /// <returns>The response from the AssignPrivateIpAddresses service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateIpAddresses">REST API Reference for AssignPrivateIpAddresses Operation</seealso>
        public virtual AssignPrivateIpAddressesResponse AssignPrivateIpAddresses(AssignPrivateIpAddressesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssignPrivateIpAddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssignPrivateIpAddressesResponseUnmarshaller.Instance;

            return Invoke<AssignPrivateIpAddressesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssignPrivateIpAddresses operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssignPrivateIpAddresses operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssignPrivateIpAddresses
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateIpAddresses">REST API Reference for AssignPrivateIpAddresses Operation</seealso>
        public virtual IAsyncResult BeginAssignPrivateIpAddresses(AssignPrivateIpAddressesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssignPrivateIpAddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssignPrivateIpAddressesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssignPrivateIpAddresses operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssignPrivateIpAddresses.</param>
        /// 
        /// <returns>Returns a  AssignPrivateIpAddressesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateIpAddresses">REST API Reference for AssignPrivateIpAddresses Operation</seealso>
        public virtual AssignPrivateIpAddressesResponse EndAssignPrivateIpAddresses(IAsyncResult asyncResult)
        {
            return EndInvoke<AssignPrivateIpAddressesResponse>(asyncResult);
        }

        #endregion
        
        #region  AssignPrivateNatGatewayAddress

        /// <summary>
        /// Assigns one or more private IPv4 addresses to a private NAT gateway. For more information,
        /// see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-working-with">Work
        /// with NAT gateways</a> in the <i>Amazon VPC User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssignPrivateNatGatewayAddress service method.</param>
        /// 
        /// <returns>The response from the AssignPrivateNatGatewayAddress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateNatGatewayAddress">REST API Reference for AssignPrivateNatGatewayAddress Operation</seealso>
        public virtual AssignPrivateNatGatewayAddressResponse AssignPrivateNatGatewayAddress(AssignPrivateNatGatewayAddressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssignPrivateNatGatewayAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssignPrivateNatGatewayAddressResponseUnmarshaller.Instance;

            return Invoke<AssignPrivateNatGatewayAddressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssignPrivateNatGatewayAddress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssignPrivateNatGatewayAddress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssignPrivateNatGatewayAddress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateNatGatewayAddress">REST API Reference for AssignPrivateNatGatewayAddress Operation</seealso>
        public virtual IAsyncResult BeginAssignPrivateNatGatewayAddress(AssignPrivateNatGatewayAddressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssignPrivateNatGatewayAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssignPrivateNatGatewayAddressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssignPrivateNatGatewayAddress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssignPrivateNatGatewayAddress.</param>
        /// 
        /// <returns>Returns a  AssignPrivateNatGatewayAddressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssignPrivateNatGatewayAddress">REST API Reference for AssignPrivateNatGatewayAddress Operation</seealso>
        public virtual AssignPrivateNatGatewayAddressResponse EndAssignPrivateNatGatewayAddress(IAsyncResult asyncResult)
        {
            return EndInvoke<AssignPrivateNatGatewayAddressResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateAddress

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// [Subnets in Wavelength Zones] You can associate an IP address from the telecommunication
        /// carrier to the instance or network interface. 
        /// </para>
        ///  
        /// <para>
        /// You cannot associate an Elastic IP address with an interface in a different network
        /// border group.
        /// </para>
        ///  <important> 
        /// <para>
        /// This is an idempotent operation. If you perform the operation more than once, Amazon
        /// EC2 doesn't return an error, and you may be charged for each time the Elastic IP address
        /// is remapped to the same instance. For more information, see the <i>Elastic IP Addresses</i>
        /// section of <a href="http://aws.amazon.com/ec2/pricing/">Amazon EC2 Pricing</a>.
        /// </para>
        ///  </important>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateAddress service method.</param>
        /// 
        /// <returns>The response from the AssociateAddress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateAddress">REST API Reference for AssociateAddress Operation</seealso>
        public virtual AssociateAddressResponse AssociateAddress(AssociateAddressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateAddressResponseUnmarshaller.Instance;

            return Invoke<AssociateAddressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateAddress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateAddress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateAddress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateAddress">REST API Reference for AssociateAddress Operation</seealso>
        public virtual IAsyncResult BeginAssociateAddress(AssociateAddressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateAddressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateAddress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateAddress.</param>
        /// 
        /// <returns>Returns a  AssociateAddressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateAddress">REST API Reference for AssociateAddress Operation</seealso>
        public virtual AssociateAddressResponse EndAssociateAddress(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateAddressResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateClientVpnTargetNetwork

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// If you specified a VPC when you created the Client VPN endpoint or if you have previous
        /// subnet associations, the specified subnet must be in the same VPC. To specify a subnet
        /// that's in a different VPC, you must first modify the Client VPN endpoint (<a>ModifyClientVpnEndpoint</a>)
        /// and change the VPC that's associated with it.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateClientVpnTargetNetwork service method.</param>
        /// 
        /// <returns>The response from the AssociateClientVpnTargetNetwork service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateClientVpnTargetNetwork">REST API Reference for AssociateClientVpnTargetNetwork Operation</seealso>
        public virtual AssociateClientVpnTargetNetworkResponse AssociateClientVpnTargetNetwork(AssociateClientVpnTargetNetworkRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateClientVpnTargetNetworkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateClientVpnTargetNetworkResponseUnmarshaller.Instance;

            return Invoke<AssociateClientVpnTargetNetworkResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateClientVpnTargetNetwork operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateClientVpnTargetNetwork operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateClientVpnTargetNetwork
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateClientVpnTargetNetwork">REST API Reference for AssociateClientVpnTargetNetwork Operation</seealso>
        public virtual IAsyncResult BeginAssociateClientVpnTargetNetwork(AssociateClientVpnTargetNetworkRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateClientVpnTargetNetworkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateClientVpnTargetNetworkResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateClientVpnTargetNetwork operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateClientVpnTargetNetwork.</param>
        /// 
        /// <returns>Returns a  AssociateClientVpnTargetNetworkResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateClientVpnTargetNetwork">REST API Reference for AssociateClientVpnTargetNetwork Operation</seealso>
        public virtual AssociateClientVpnTargetNetworkResponse EndAssociateClientVpnTargetNetwork(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateClientVpnTargetNetworkResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateDhcpOptions

        /// <summary>
        /// Associates a set of DHCP options (that you've previously created) with the specified
        /// VPC, or associates no DHCP options with the VPC.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP
        /// options sets</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateDhcpOptions service method.</param>
        /// 
        /// <returns>The response from the AssociateDhcpOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateDhcpOptions">REST API Reference for AssociateDhcpOptions Operation</seealso>
        public virtual AssociateDhcpOptionsResponse AssociateDhcpOptions(AssociateDhcpOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateDhcpOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateDhcpOptionsResponseUnmarshaller.Instance;

            return Invoke<AssociateDhcpOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateDhcpOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateDhcpOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateDhcpOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateDhcpOptions">REST API Reference for AssociateDhcpOptions Operation</seealso>
        public virtual IAsyncResult BeginAssociateDhcpOptions(AssociateDhcpOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateDhcpOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateDhcpOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateDhcpOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateDhcpOptions.</param>
        /// 
        /// <returns>Returns a  AssociateDhcpOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateDhcpOptions">REST API Reference for AssociateDhcpOptions Operation</seealso>
        public virtual AssociateDhcpOptionsResponse EndAssociateDhcpOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateDhcpOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateEnclaveCertificateIamRole

        /// <summary>
        /// Associates an Identity and Access Management (IAM) role with an Certificate Manager
        /// (ACM) certificate. This enables the certificate to be used by the ACM for Nitro Enclaves
        /// application inside an enclave. For more information, see <a href="https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave-refapp.html">Certificate
        /// Manager for Nitro Enclaves</a> in the <i>Amazon Web Services Nitro Enclaves User Guide</i>.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// To enable the IAM role to access the Amazon S3 object, you must grant it permission
        /// to call <code>s3:GetObject</code> on the Amazon S3 bucket returned by the command.
        /// To enable the IAM role to access the KMS key, you must grant it permission to call
        /// <code>kms:Decrypt</code> on the KMS key returned by the command. For more information,
        /// see <a href="https://docs.aws.amazon.com/enclaves/latest/user/nitro-enclave-refapp.html#add-policy">
        /// Grant the role permission to access the certificate and encryption key</a> in the
        /// <i>Amazon Web Services Nitro Enclaves User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateEnclaveCertificateIamRole service method.</param>
        /// 
        /// <returns>The response from the AssociateEnclaveCertificateIamRole service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateEnclaveCertificateIamRole">REST API Reference for AssociateEnclaveCertificateIamRole Operation</seealso>
        public virtual AssociateEnclaveCertificateIamRoleResponse AssociateEnclaveCertificateIamRole(AssociateEnclaveCertificateIamRoleRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateEnclaveCertificateIamRoleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateEnclaveCertificateIamRoleResponseUnmarshaller.Instance;

            return Invoke<AssociateEnclaveCertificateIamRoleResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateEnclaveCertificateIamRole operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateEnclaveCertificateIamRole operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateEnclaveCertificateIamRole
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateEnclaveCertificateIamRole">REST API Reference for AssociateEnclaveCertificateIamRole Operation</seealso>
        public virtual IAsyncResult BeginAssociateEnclaveCertificateIamRole(AssociateEnclaveCertificateIamRoleRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateEnclaveCertificateIamRoleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateEnclaveCertificateIamRoleResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateEnclaveCertificateIamRole operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateEnclaveCertificateIamRole.</param>
        /// 
        /// <returns>Returns a  AssociateEnclaveCertificateIamRoleResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateEnclaveCertificateIamRole">REST API Reference for AssociateEnclaveCertificateIamRole Operation</seealso>
        public virtual AssociateEnclaveCertificateIamRoleResponse EndAssociateEnclaveCertificateIamRole(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateEnclaveCertificateIamRoleResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateIamInstanceProfile

        /// <summary>
        /// Associates an IAM instance profile with a running or stopped instance. You cannot
        /// associate more than one IAM instance profile with an instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateIamInstanceProfile service method.</param>
        /// 
        /// <returns>The response from the AssociateIamInstanceProfile service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIamInstanceProfile">REST API Reference for AssociateIamInstanceProfile Operation</seealso>
        public virtual AssociateIamInstanceProfileResponse AssociateIamInstanceProfile(AssociateIamInstanceProfileRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateIamInstanceProfileRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateIamInstanceProfileResponseUnmarshaller.Instance;

            return Invoke<AssociateIamInstanceProfileResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateIamInstanceProfile operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateIamInstanceProfile operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateIamInstanceProfile
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIamInstanceProfile">REST API Reference for AssociateIamInstanceProfile Operation</seealso>
        public virtual IAsyncResult BeginAssociateIamInstanceProfile(AssociateIamInstanceProfileRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateIamInstanceProfileRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateIamInstanceProfileResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateIamInstanceProfile operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateIamInstanceProfile.</param>
        /// 
        /// <returns>Returns a  AssociateIamInstanceProfileResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIamInstanceProfile">REST API Reference for AssociateIamInstanceProfile Operation</seealso>
        public virtual AssociateIamInstanceProfileResponse EndAssociateIamInstanceProfile(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateIamInstanceProfileResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateInstanceEventWindow

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
        /// event windows for scheduled events</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateInstanceEventWindow service method.</param>
        /// 
        /// <returns>The response from the AssociateInstanceEventWindow service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateInstanceEventWindow">REST API Reference for AssociateInstanceEventWindow Operation</seealso>
        public virtual AssociateInstanceEventWindowResponse AssociateInstanceEventWindow(AssociateInstanceEventWindowRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateInstanceEventWindowResponseUnmarshaller.Instance;

            return Invoke<AssociateInstanceEventWindowResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateInstanceEventWindow operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateInstanceEventWindow
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateInstanceEventWindow">REST API Reference for AssociateInstanceEventWindow Operation</seealso>
        public virtual IAsyncResult BeginAssociateInstanceEventWindow(AssociateInstanceEventWindowRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateInstanceEventWindowResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateInstanceEventWindow.</param>
        /// 
        /// <returns>Returns a  AssociateInstanceEventWindowResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateInstanceEventWindow">REST API Reference for AssociateInstanceEventWindow Operation</seealso>
        public virtual AssociateInstanceEventWindowResponse EndAssociateInstanceEventWindow(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateInstanceEventWindowResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateIpamResourceDiscovery

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateIpamResourceDiscovery service method.</param>
        /// 
        /// <returns>The response from the AssociateIpamResourceDiscovery service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIpamResourceDiscovery">REST API Reference for AssociateIpamResourceDiscovery Operation</seealso>
        public virtual AssociateIpamResourceDiscoveryResponse AssociateIpamResourceDiscovery(AssociateIpamResourceDiscoveryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return Invoke<AssociateIpamResourceDiscoveryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateIpamResourceDiscovery operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateIpamResourceDiscovery
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIpamResourceDiscovery">REST API Reference for AssociateIpamResourceDiscovery Operation</seealso>
        public virtual IAsyncResult BeginAssociateIpamResourceDiscovery(AssociateIpamResourceDiscoveryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateIpamResourceDiscovery.</param>
        /// 
        /// <returns>Returns a  AssociateIpamResourceDiscoveryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateIpamResourceDiscovery">REST API Reference for AssociateIpamResourceDiscovery Operation</seealso>
        public virtual AssociateIpamResourceDiscoveryResponse EndAssociateIpamResourceDiscovery(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateIpamResourceDiscoveryResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateNatGatewayAddress

        /// <summary>
        /// Associates Elastic IP addresses (EIPs) and private IPv4 addresses with a public NAT
        /// gateway. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-working-with">Work
        /// with NAT gateways</a> in the <i>Amazon VPC User Guide</i>.
        /// 
        ///  
        /// <para>
        /// By default, you can associate up to 2 Elastic IP addresses per public NAT gateway.
        /// You can increase the limit by requesting a quota adjustment. For more information,
        /// see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html#vpc-limits-eips">Elastic
        /// IP address quotas</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateNatGatewayAddress service method.</param>
        /// 
        /// <returns>The response from the AssociateNatGatewayAddress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateNatGatewayAddress">REST API Reference for AssociateNatGatewayAddress Operation</seealso>
        public virtual AssociateNatGatewayAddressResponse AssociateNatGatewayAddress(AssociateNatGatewayAddressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateNatGatewayAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateNatGatewayAddressResponseUnmarshaller.Instance;

            return Invoke<AssociateNatGatewayAddressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateNatGatewayAddress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateNatGatewayAddress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateNatGatewayAddress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateNatGatewayAddress">REST API Reference for AssociateNatGatewayAddress Operation</seealso>
        public virtual IAsyncResult BeginAssociateNatGatewayAddress(AssociateNatGatewayAddressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateNatGatewayAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateNatGatewayAddressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateNatGatewayAddress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateNatGatewayAddress.</param>
        /// 
        /// <returns>Returns a  AssociateNatGatewayAddressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateNatGatewayAddress">REST API Reference for AssociateNatGatewayAddress Operation</seealso>
        public virtual AssociateNatGatewayAddressResponse EndAssociateNatGatewayAddress(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateNatGatewayAddressResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateRouteTable

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
        /// tables</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateRouteTable service method.</param>
        /// 
        /// <returns>The response from the AssociateRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateRouteTable">REST API Reference for AssociateRouteTable Operation</seealso>
        public virtual AssociateRouteTableResponse AssociateRouteTable(AssociateRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateRouteTableResponseUnmarshaller.Instance;

            return Invoke<AssociateRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateRouteTable">REST API Reference for AssociateRouteTable Operation</seealso>
        public virtual IAsyncResult BeginAssociateRouteTable(AssociateRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateRouteTable.</param>
        /// 
        /// <returns>Returns a  AssociateRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateRouteTable">REST API Reference for AssociateRouteTable Operation</seealso>
        public virtual AssociateRouteTableResponse EndAssociateRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateSubnetCidrBlock

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateSubnetCidrBlock service method.</param>
        /// 
        /// <returns>The response from the AssociateSubnetCidrBlock service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateSubnetCidrBlock">REST API Reference for AssociateSubnetCidrBlock Operation</seealso>
        public virtual AssociateSubnetCidrBlockResponse AssociateSubnetCidrBlock(AssociateSubnetCidrBlockRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateSubnetCidrBlockRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateSubnetCidrBlockResponseUnmarshaller.Instance;

            return Invoke<AssociateSubnetCidrBlockResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateSubnetCidrBlock operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateSubnetCidrBlock operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateSubnetCidrBlock
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateSubnetCidrBlock">REST API Reference for AssociateSubnetCidrBlock Operation</seealso>
        public virtual IAsyncResult BeginAssociateSubnetCidrBlock(AssociateSubnetCidrBlockRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateSubnetCidrBlockRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateSubnetCidrBlockResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateSubnetCidrBlock operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateSubnetCidrBlock.</param>
        /// 
        /// <returns>Returns a  AssociateSubnetCidrBlockResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateSubnetCidrBlock">REST API Reference for AssociateSubnetCidrBlock Operation</seealso>
        public virtual AssociateSubnetCidrBlockResponse EndAssociateSubnetCidrBlock(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateSubnetCidrBlockResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateTransitGatewayMulticastDomain

        /// <summary>
        /// Associates the specified subnets and transit gateway attachments with the specified
        /// transit gateway multicast domain.
        /// 
        ///  
        /// <para>
        /// The transit gateway attachment must be in the available state before you can add a
        /// resource. Use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeTransitGatewayAttachments.html">DescribeTransitGatewayAttachments</a>
        /// to see the state of the attachment.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateTransitGatewayMulticastDomain service method.</param>
        /// 
        /// <returns>The response from the AssociateTransitGatewayMulticastDomain service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayMulticastDomain">REST API Reference for AssociateTransitGatewayMulticastDomain Operation</seealso>
        public virtual AssociateTransitGatewayMulticastDomainResponse AssociateTransitGatewayMulticastDomain(AssociateTransitGatewayMulticastDomainRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateTransitGatewayMulticastDomainRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateTransitGatewayMulticastDomainResponseUnmarshaller.Instance;

            return Invoke<AssociateTransitGatewayMulticastDomainResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateTransitGatewayMulticastDomain operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateTransitGatewayMulticastDomain operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateTransitGatewayMulticastDomain
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayMulticastDomain">REST API Reference for AssociateTransitGatewayMulticastDomain Operation</seealso>
        public virtual IAsyncResult BeginAssociateTransitGatewayMulticastDomain(AssociateTransitGatewayMulticastDomainRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateTransitGatewayMulticastDomainRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateTransitGatewayMulticastDomainResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateTransitGatewayMulticastDomain operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateTransitGatewayMulticastDomain.</param>
        /// 
        /// <returns>Returns a  AssociateTransitGatewayMulticastDomainResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayMulticastDomain">REST API Reference for AssociateTransitGatewayMulticastDomain Operation</seealso>
        public virtual AssociateTransitGatewayMulticastDomainResponse EndAssociateTransitGatewayMulticastDomain(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateTransitGatewayMulticastDomainResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateTransitGatewayPolicyTable

        /// <summary>
        /// Associates the specified transit gateway attachment with a transit gateway policy
        /// table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateTransitGatewayPolicyTable service method.</param>
        /// 
        /// <returns>The response from the AssociateTransitGatewayPolicyTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayPolicyTable">REST API Reference for AssociateTransitGatewayPolicyTable Operation</seealso>
        public virtual AssociateTransitGatewayPolicyTableResponse AssociateTransitGatewayPolicyTable(AssociateTransitGatewayPolicyTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateTransitGatewayPolicyTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateTransitGatewayPolicyTableResponseUnmarshaller.Instance;

            return Invoke<AssociateTransitGatewayPolicyTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateTransitGatewayPolicyTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateTransitGatewayPolicyTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateTransitGatewayPolicyTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayPolicyTable">REST API Reference for AssociateTransitGatewayPolicyTable Operation</seealso>
        public virtual IAsyncResult BeginAssociateTransitGatewayPolicyTable(AssociateTransitGatewayPolicyTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateTransitGatewayPolicyTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateTransitGatewayPolicyTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateTransitGatewayPolicyTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateTransitGatewayPolicyTable.</param>
        /// 
        /// <returns>Returns a  AssociateTransitGatewayPolicyTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayPolicyTable">REST API Reference for AssociateTransitGatewayPolicyTable Operation</seealso>
        public virtual AssociateTransitGatewayPolicyTableResponse EndAssociateTransitGatewayPolicyTable(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateTransitGatewayPolicyTableResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateTransitGatewayRouteTable

        /// <summary>
        /// Associates the specified attachment with the specified transit gateway route table.
        /// You can associate only one route table with an attachment.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateTransitGatewayRouteTable service method.</param>
        /// 
        /// <returns>The response from the AssociateTransitGatewayRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayRouteTable">REST API Reference for AssociateTransitGatewayRouteTable Operation</seealso>
        public virtual AssociateTransitGatewayRouteTableResponse AssociateTransitGatewayRouteTable(AssociateTransitGatewayRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateTransitGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateTransitGatewayRouteTableResponseUnmarshaller.Instance;

            return Invoke<AssociateTransitGatewayRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateTransitGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateTransitGatewayRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateTransitGatewayRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayRouteTable">REST API Reference for AssociateTransitGatewayRouteTable Operation</seealso>
        public virtual IAsyncResult BeginAssociateTransitGatewayRouteTable(AssociateTransitGatewayRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateTransitGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateTransitGatewayRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateTransitGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateTransitGatewayRouteTable.</param>
        /// 
        /// <returns>Returns a  AssociateTransitGatewayRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTransitGatewayRouteTable">REST API Reference for AssociateTransitGatewayRouteTable Operation</seealso>
        public virtual AssociateTransitGatewayRouteTableResponse EndAssociateTransitGatewayRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateTransitGatewayRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateTrunkInterface

        /// <summary>
        /// <note> 
        /// <para>
        /// This API action is currently in <b>limited preview only</b>. If you are interested
        /// in using this feature, contact your account manager.
        /// </para>
        ///  </note> 
        /// <para>
        /// Associates a branch network interface with a trunk network interface.
        /// </para>
        ///  
        /// <para>
        /// Before you create the association, run the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateNetworkInterface.html">create-network-interface</a>
        /// command and set <code>--interface-type</code> to <code>trunk</code>. You must also
        /// create a network interface for each branch network interface that you want to associate
        /// with the trunk network interface.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateTrunkInterface service method.</param>
        /// 
        /// <returns>The response from the AssociateTrunkInterface service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTrunkInterface">REST API Reference for AssociateTrunkInterface Operation</seealso>
        public virtual AssociateTrunkInterfaceResponse AssociateTrunkInterface(AssociateTrunkInterfaceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateTrunkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateTrunkInterfaceResponseUnmarshaller.Instance;

            return Invoke<AssociateTrunkInterfaceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateTrunkInterface operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateTrunkInterface operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateTrunkInterface
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTrunkInterface">REST API Reference for AssociateTrunkInterface Operation</seealso>
        public virtual IAsyncResult BeginAssociateTrunkInterface(AssociateTrunkInterfaceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateTrunkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateTrunkInterfaceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateTrunkInterface operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateTrunkInterface.</param>
        /// 
        /// <returns>Returns a  AssociateTrunkInterfaceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateTrunkInterface">REST API Reference for AssociateTrunkInterface Operation</seealso>
        public virtual AssociateTrunkInterfaceResponse EndAssociateTrunkInterface(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateTrunkInterfaceResponse>(asyncResult);
        }

        #endregion
        
        #region  AssociateVpcCidrBlock

        /// <summary>
        /// Associates a CIDR block with your VPC. You can associate a secondary IPv4 CIDR block,
        /// an Amazon-provided IPv6 CIDR block, or an IPv6 CIDR block from an IPv6 address pool
        /// that you provisioned through bring your own IP addresses (<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">BYOIP</a>).
        /// The IPv6 CIDR block size is fixed at /56.
        /// 
        ///  
        /// <para>
        /// You must specify one of the following in the request: an IPv4 CIDR block, an IPv6
        /// pool, or an Amazon-provided IPv6 CIDR block.
        /// </para>
        ///  
        /// <para>
        /// For more information about associating CIDR blocks with your VPC and applicable restrictions,
        /// see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-ip-addressing.html">IP
        /// addressing for your VPCs and subnets</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AssociateVpcCidrBlock service method.</param>
        /// 
        /// <returns>The response from the AssociateVpcCidrBlock service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateVpcCidrBlock">REST API Reference for AssociateVpcCidrBlock Operation</seealso>
        public virtual AssociateVpcCidrBlockResponse AssociateVpcCidrBlock(AssociateVpcCidrBlockRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateVpcCidrBlockRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateVpcCidrBlockResponseUnmarshaller.Instance;

            return Invoke<AssociateVpcCidrBlockResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AssociateVpcCidrBlock operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AssociateVpcCidrBlock operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateVpcCidrBlock
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateVpcCidrBlock">REST API Reference for AssociateVpcCidrBlock Operation</seealso>
        public virtual IAsyncResult BeginAssociateVpcCidrBlock(AssociateVpcCidrBlockRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AssociateVpcCidrBlockRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AssociateVpcCidrBlockResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AssociateVpcCidrBlock operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAssociateVpcCidrBlock.</param>
        /// 
        /// <returns>Returns a  AssociateVpcCidrBlockResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AssociateVpcCidrBlock">REST API Reference for AssociateVpcCidrBlock Operation</seealso>
        public virtual AssociateVpcCidrBlockResponse EndAssociateVpcCidrBlock(IAsyncResult asyncResult)
        {
            return EndInvoke<AssociateVpcCidrBlockResponse>(asyncResult);
        }

        #endregion
        
        #region  AttachClassicLinkVpc

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Links an EC2-Classic instance to a ClassicLink-enabled VPC through one or more of
        /// the VPC security groups. You cannot link an EC2-Classic instance to more than one
        /// VPC at a time. You can only link an instance that's in the <code>running</code> state.
        /// An instance is automatically unlinked from a VPC when it's stopped - you can link
        /// it to the VPC again when you restart it.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// Linking your instance to a VPC is sometimes referred to as <i>attaching</i> your instance.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AttachClassicLinkVpc service method.</param>
        /// 
        /// <returns>The response from the AttachClassicLinkVpc service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachClassicLinkVpc">REST API Reference for AttachClassicLinkVpc Operation</seealso>
        public virtual AttachClassicLinkVpcResponse AttachClassicLinkVpc(AttachClassicLinkVpcRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachClassicLinkVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachClassicLinkVpcResponseUnmarshaller.Instance;

            return Invoke<AttachClassicLinkVpcResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AttachClassicLinkVpc operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AttachClassicLinkVpc operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachClassicLinkVpc
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachClassicLinkVpc">REST API Reference for AttachClassicLinkVpc Operation</seealso>
        public virtual IAsyncResult BeginAttachClassicLinkVpc(AttachClassicLinkVpcRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachClassicLinkVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachClassicLinkVpcResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AttachClassicLinkVpc operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAttachClassicLinkVpc.</param>
        /// 
        /// <returns>Returns a  AttachClassicLinkVpcResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachClassicLinkVpc">REST API Reference for AttachClassicLinkVpc Operation</seealso>
        public virtual AttachClassicLinkVpcResponse EndAttachClassicLinkVpc(IAsyncResult asyncResult)
        {
            return EndInvoke<AttachClassicLinkVpcResponse>(asyncResult);
        }

        #endregion
        
        #region  AttachInternetGateway

        /// <summary>
        /// Attaches an internet gateway or a virtual private gateway to a VPC, enabling connectivity
        /// between the internet and the VPC. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html">Internet
        /// gateways</a> in the <i>Amazon VPC User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AttachInternetGateway service method.</param>
        /// 
        /// <returns>The response from the AttachInternetGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachInternetGateway">REST API Reference for AttachInternetGateway Operation</seealso>
        public virtual AttachInternetGatewayResponse AttachInternetGateway(AttachInternetGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachInternetGatewayResponseUnmarshaller.Instance;

            return Invoke<AttachInternetGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AttachInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AttachInternetGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachInternetGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachInternetGateway">REST API Reference for AttachInternetGateway Operation</seealso>
        public virtual IAsyncResult BeginAttachInternetGateway(AttachInternetGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachInternetGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AttachInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAttachInternetGateway.</param>
        /// 
        /// <returns>Returns a  AttachInternetGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachInternetGateway">REST API Reference for AttachInternetGateway Operation</seealso>
        public virtual AttachInternetGatewayResponse EndAttachInternetGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<AttachInternetGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  AttachNetworkInterface

        /// <summary>
        /// Attaches a network interface to an instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AttachNetworkInterface service method.</param>
        /// 
        /// <returns>The response from the AttachNetworkInterface service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachNetworkInterface">REST API Reference for AttachNetworkInterface Operation</seealso>
        public virtual AttachNetworkInterfaceResponse AttachNetworkInterface(AttachNetworkInterfaceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachNetworkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachNetworkInterfaceResponseUnmarshaller.Instance;

            return Invoke<AttachNetworkInterfaceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AttachNetworkInterface operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AttachNetworkInterface operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachNetworkInterface
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachNetworkInterface">REST API Reference for AttachNetworkInterface Operation</seealso>
        public virtual IAsyncResult BeginAttachNetworkInterface(AttachNetworkInterfaceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachNetworkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachNetworkInterfaceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AttachNetworkInterface operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAttachNetworkInterface.</param>
        /// 
        /// <returns>Returns a  AttachNetworkInterfaceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachNetworkInterface">REST API Reference for AttachNetworkInterface Operation</seealso>
        public virtual AttachNetworkInterfaceResponse EndAttachNetworkInterface(IAsyncResult asyncResult)
        {
            return EndInvoke<AttachNetworkInterfaceResponse>(asyncResult);
        }

        #endregion
        
        #region  AttachVerifiedAccessTrustProvider

        /// <summary>
        /// Attaches the specified Amazon Web Services Verified Access trust provider to the specified
        /// Amazon Web Services Verified Access instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AttachVerifiedAccessTrustProvider service method.</param>
        /// 
        /// <returns>The response from the AttachVerifiedAccessTrustProvider service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVerifiedAccessTrustProvider">REST API Reference for AttachVerifiedAccessTrustProvider Operation</seealso>
        public virtual AttachVerifiedAccessTrustProviderResponse AttachVerifiedAccessTrustProvider(AttachVerifiedAccessTrustProviderRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return Invoke<AttachVerifiedAccessTrustProviderResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AttachVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AttachVerifiedAccessTrustProvider operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachVerifiedAccessTrustProvider
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVerifiedAccessTrustProvider">REST API Reference for AttachVerifiedAccessTrustProvider Operation</seealso>
        public virtual IAsyncResult BeginAttachVerifiedAccessTrustProvider(AttachVerifiedAccessTrustProviderRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AttachVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAttachVerifiedAccessTrustProvider.</param>
        /// 
        /// <returns>Returns a  AttachVerifiedAccessTrustProviderResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVerifiedAccessTrustProvider">REST API Reference for AttachVerifiedAccessTrustProvider Operation</seealso>
        public virtual AttachVerifiedAccessTrustProviderResponse EndAttachVerifiedAccessTrustProvider(IAsyncResult asyncResult)
        {
            return EndInvoke<AttachVerifiedAccessTrustProviderResponse>(asyncResult);
        }

        #endregion
        
        #region  AttachVolume

        /// <summary>
        /// Attaches an EBS volume to a running or stopped instance and exposes it to the instance
        /// with the specified device name.
        /// 
        ///  
        /// <para>
        /// Encrypted EBS volumes must be attached to instances that support Amazon EBS encryption.
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon
        /// EBS encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// After you attach an EBS volume, you must make it available. For more information,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-using-volumes.html">Make
        /// an EBS volume available for use</a>.
        /// </para>
        ///  
        /// <para>
        /// If a volume has an Amazon Web Services Marketplace product code:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        /// The volume can be attached only to a stopped instance.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Amazon Web Services Marketplace product codes are copied from the volume to the instance.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// You must be subscribed to the product.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// 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.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-attaching-volume.html">Attach
        /// an Amazon EBS volume to an instance</a> in the <i>Amazon Elastic Compute Cloud User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AttachVolume service method.</param>
        /// 
        /// <returns>The response from the AttachVolume service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVolume">REST API Reference for AttachVolume Operation</seealso>
        public virtual AttachVolumeResponse AttachVolume(AttachVolumeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachVolumeResponseUnmarshaller.Instance;

            return Invoke<AttachVolumeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AttachVolume operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AttachVolume operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachVolume
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVolume">REST API Reference for AttachVolume Operation</seealso>
        public virtual IAsyncResult BeginAttachVolume(AttachVolumeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachVolumeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AttachVolume operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAttachVolume.</param>
        /// 
        /// <returns>Returns a  AttachVolumeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVolume">REST API Reference for AttachVolume Operation</seealso>
        public virtual AttachVolumeResponse EndAttachVolume(IAsyncResult asyncResult)
        {
            return EndInvoke<AttachVolumeResponse>(asyncResult);
        }

        #endregion
        
        #region  AttachVpnGateway

        /// <summary>
        /// Attaches a virtual private gateway to a VPC. You can attach one virtual private gateway
        /// to one VPC at a time.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AttachVpnGateway service method.</param>
        /// 
        /// <returns>The response from the AttachVpnGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVpnGateway">REST API Reference for AttachVpnGateway Operation</seealso>
        public virtual AttachVpnGatewayResponse AttachVpnGateway(AttachVpnGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachVpnGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachVpnGatewayResponseUnmarshaller.Instance;

            return Invoke<AttachVpnGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AttachVpnGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AttachVpnGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAttachVpnGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVpnGateway">REST API Reference for AttachVpnGateway Operation</seealso>
        public virtual IAsyncResult BeginAttachVpnGateway(AttachVpnGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AttachVpnGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AttachVpnGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AttachVpnGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAttachVpnGateway.</param>
        /// 
        /// <returns>Returns a  AttachVpnGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AttachVpnGateway">REST API Reference for AttachVpnGateway Operation</seealso>
        public virtual AttachVpnGatewayResponse EndAttachVpnGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<AttachVpnGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  AuthorizeClientVpnIngress

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AuthorizeClientVpnIngress service method.</param>
        /// 
        /// <returns>The response from the AuthorizeClientVpnIngress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeClientVpnIngress">REST API Reference for AuthorizeClientVpnIngress Operation</seealso>
        public virtual AuthorizeClientVpnIngressResponse AuthorizeClientVpnIngress(AuthorizeClientVpnIngressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AuthorizeClientVpnIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AuthorizeClientVpnIngressResponseUnmarshaller.Instance;

            return Invoke<AuthorizeClientVpnIngressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AuthorizeClientVpnIngress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AuthorizeClientVpnIngress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAuthorizeClientVpnIngress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeClientVpnIngress">REST API Reference for AuthorizeClientVpnIngress Operation</seealso>
        public virtual IAsyncResult BeginAuthorizeClientVpnIngress(AuthorizeClientVpnIngressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AuthorizeClientVpnIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AuthorizeClientVpnIngressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AuthorizeClientVpnIngress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAuthorizeClientVpnIngress.</param>
        /// 
        /// <returns>Returns a  AuthorizeClientVpnIngressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeClientVpnIngress">REST API Reference for AuthorizeClientVpnIngress Operation</seealso>
        public virtual AuthorizeClientVpnIngressResponse EndAuthorizeClientVpnIngress(IAsyncResult asyncResult)
        {
            return EndInvoke<AuthorizeClientVpnIngressResponse>(asyncResult);
        }

        #endregion
        
        #region  AuthorizeSecurityGroupEgress

        /// <summary>
        /// Adds the specified outbound (egress) rules to a security group for use with a VPC.
        /// 
        ///  
        /// <para>
        /// 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 <code>IpPermissions</code> must include a destination for the traffic.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// Rule changes are propagated to affected instances as quickly as possible. However,
        /// a small delay might occur.
        /// </para>
        ///  
        /// <para>
        /// For information about VPC security group quotas, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon
        /// VPC quotas</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AuthorizeSecurityGroupEgress service method.</param>
        /// 
        /// <returns>The response from the AuthorizeSecurityGroupEgress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupEgress">REST API Reference for AuthorizeSecurityGroupEgress Operation</seealso>
        public virtual AuthorizeSecurityGroupEgressResponse AuthorizeSecurityGroupEgress(AuthorizeSecurityGroupEgressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AuthorizeSecurityGroupEgressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AuthorizeSecurityGroupEgressResponseUnmarshaller.Instance;

            return Invoke<AuthorizeSecurityGroupEgressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AuthorizeSecurityGroupEgress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AuthorizeSecurityGroupEgress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAuthorizeSecurityGroupEgress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupEgress">REST API Reference for AuthorizeSecurityGroupEgress Operation</seealso>
        public virtual IAsyncResult BeginAuthorizeSecurityGroupEgress(AuthorizeSecurityGroupEgressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AuthorizeSecurityGroupEgressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AuthorizeSecurityGroupEgressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AuthorizeSecurityGroupEgress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAuthorizeSecurityGroupEgress.</param>
        /// 
        /// <returns>Returns a  AuthorizeSecurityGroupEgressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupEgress">REST API Reference for AuthorizeSecurityGroupEgress Operation</seealso>
        public virtual AuthorizeSecurityGroupEgressResponse EndAuthorizeSecurityGroupEgress(IAsyncResult asyncResult)
        {
            return EndInvoke<AuthorizeSecurityGroupEgressResponse>(asyncResult);
        }

        #endregion
        
        #region  AuthorizeSecurityGroupIngress

        /// <summary>
        /// Adds the specified inbound (ingress) rules to a security group.
        /// 
        ///  
        /// <para>
        /// 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 <code>IpPermissions</code> must include a source for the traffic.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// Rule changes are propagated to instances within the security group as quickly as possible.
        /// However, a small delay might occur.
        /// </para>
        ///  
        /// <para>
        /// For more information about VPC security group quotas, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon
        /// VPC quotas</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the AuthorizeSecurityGroupIngress service method.</param>
        /// 
        /// <returns>The response from the AuthorizeSecurityGroupIngress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupIngress">REST API Reference for AuthorizeSecurityGroupIngress Operation</seealso>
        public virtual AuthorizeSecurityGroupIngressResponse AuthorizeSecurityGroupIngress(AuthorizeSecurityGroupIngressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AuthorizeSecurityGroupIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AuthorizeSecurityGroupIngressResponseUnmarshaller.Instance;

            return Invoke<AuthorizeSecurityGroupIngressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the AuthorizeSecurityGroupIngress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the AuthorizeSecurityGroupIngress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAuthorizeSecurityGroupIngress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupIngress">REST API Reference for AuthorizeSecurityGroupIngress Operation</seealso>
        public virtual IAsyncResult BeginAuthorizeSecurityGroupIngress(AuthorizeSecurityGroupIngressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = AuthorizeSecurityGroupIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = AuthorizeSecurityGroupIngressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  AuthorizeSecurityGroupIngress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginAuthorizeSecurityGroupIngress.</param>
        /// 
        /// <returns>Returns a  AuthorizeSecurityGroupIngressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/AuthorizeSecurityGroupIngress">REST API Reference for AuthorizeSecurityGroupIngress Operation</seealso>
        public virtual AuthorizeSecurityGroupIngressResponse EndAuthorizeSecurityGroupIngress(IAsyncResult asyncResult)
        {
            return EndInvoke<AuthorizeSecurityGroupIngressResponse>(asyncResult);
        }

        #endregion
        
        #region  BundleInstance

        /// <summary>
        /// Bundles an Amazon instance store-backed Windows instance.
        /// 
        ///  
        /// <para>
        /// During bundling, only the root device volume (C:\) is bundled. Data on other instance
        /// store volumes is not preserved.
        /// </para>
        ///  <note> 
        /// <para>
        /// This action is not applicable for Linux/Unix instances or Windows instances that are
        /// backed by Amazon EBS.
        /// </para>
        ///  </note>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the BundleInstance service method.</param>
        /// 
        /// <returns>The response from the BundleInstance service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/BundleInstance">REST API Reference for BundleInstance Operation</seealso>
        public virtual BundleInstanceResponse BundleInstance(BundleInstanceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = BundleInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = BundleInstanceResponseUnmarshaller.Instance;

            return Invoke<BundleInstanceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the BundleInstance operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the BundleInstance operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBundleInstance
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/BundleInstance">REST API Reference for BundleInstance Operation</seealso>
        public virtual IAsyncResult BeginBundleInstance(BundleInstanceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = BundleInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = BundleInstanceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  BundleInstance operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginBundleInstance.</param>
        /// 
        /// <returns>Returns a  BundleInstanceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/BundleInstance">REST API Reference for BundleInstance Operation</seealso>
        public virtual BundleInstanceResponse EndBundleInstance(IAsyncResult asyncResult)
        {
            return EndInvoke<BundleInstanceResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelBundleTask

        /// <summary>
        /// Cancels a bundling operation for an instance store-backed Windows instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelBundleTask service method.</param>
        /// 
        /// <returns>The response from the CancelBundleTask service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelBundleTask">REST API Reference for CancelBundleTask Operation</seealso>
        public virtual CancelBundleTaskResponse CancelBundleTask(CancelBundleTaskRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelBundleTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelBundleTaskResponseUnmarshaller.Instance;

            return Invoke<CancelBundleTaskResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelBundleTask operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelBundleTask operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelBundleTask
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelBundleTask">REST API Reference for CancelBundleTask Operation</seealso>
        public virtual IAsyncResult BeginCancelBundleTask(CancelBundleTaskRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelBundleTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelBundleTaskResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelBundleTask operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelBundleTask.</param>
        /// 
        /// <returns>Returns a  CancelBundleTaskResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelBundleTask">REST API Reference for CancelBundleTask Operation</seealso>
        public virtual CancelBundleTaskResponse EndCancelBundleTask(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelBundleTaskResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelCapacityReservation

        /// <summary>
        /// Cancels the specified Capacity Reservation, releases the reserved capacity, and changes
        /// the Capacity Reservation's state to <code>cancelled</code>.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelCapacityReservation service method.</param>
        /// 
        /// <returns>The response from the CancelCapacityReservation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelCapacityReservation">REST API Reference for CancelCapacityReservation Operation</seealso>
        public virtual CancelCapacityReservationResponse CancelCapacityReservation(CancelCapacityReservationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelCapacityReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelCapacityReservationResponseUnmarshaller.Instance;

            return Invoke<CancelCapacityReservationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelCapacityReservation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelCapacityReservation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelCapacityReservation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelCapacityReservation">REST API Reference for CancelCapacityReservation Operation</seealso>
        public virtual IAsyncResult BeginCancelCapacityReservation(CancelCapacityReservationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelCapacityReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelCapacityReservationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelCapacityReservation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelCapacityReservation.</param>
        /// 
        /// <returns>Returns a  CancelCapacityReservationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelCapacityReservation">REST API Reference for CancelCapacityReservation Operation</seealso>
        public virtual CancelCapacityReservationResponse EndCancelCapacityReservation(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelCapacityReservationResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelCapacityReservationFleets

        /// <summary>
        /// Cancels one or more Capacity Reservation Fleets. When you cancel a Capacity Reservation
        /// Fleet, the following happens:
        /// 
        ///  <ul> <li> 
        /// <para>
        /// The Capacity Reservation Fleet's status changes to <code>cancelled</code>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// 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.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// The Fleet stops creating new Capacity Reservations.
        /// </para>
        ///  </li> </ul>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelCapacityReservationFleets service method.</param>
        /// 
        /// <returns>The response from the CancelCapacityReservationFleets service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelCapacityReservationFleets">REST API Reference for CancelCapacityReservationFleets Operation</seealso>
        public virtual CancelCapacityReservationFleetsResponse CancelCapacityReservationFleets(CancelCapacityReservationFleetsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelCapacityReservationFleetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelCapacityReservationFleetsResponseUnmarshaller.Instance;

            return Invoke<CancelCapacityReservationFleetsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelCapacityReservationFleets operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelCapacityReservationFleets operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelCapacityReservationFleets
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelCapacityReservationFleets">REST API Reference for CancelCapacityReservationFleets Operation</seealso>
        public virtual IAsyncResult BeginCancelCapacityReservationFleets(CancelCapacityReservationFleetsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelCapacityReservationFleetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelCapacityReservationFleetsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelCapacityReservationFleets operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelCapacityReservationFleets.</param>
        /// 
        /// <returns>Returns a  CancelCapacityReservationFleetsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelCapacityReservationFleets">REST API Reference for CancelCapacityReservationFleets Operation</seealso>
        public virtual CancelCapacityReservationFleetsResponse EndCancelCapacityReservationFleets(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelCapacityReservationFleetsResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelConversionTask

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ec2-cli-vmimport-export.html">Importing
        /// a Virtual Machine Using the Amazon EC2 CLI</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelConversionTask service method.</param>
        /// 
        /// <returns>The response from the CancelConversionTask service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelConversionTask">REST API Reference for CancelConversionTask Operation</seealso>
        public virtual CancelConversionTaskResponse CancelConversionTask(CancelConversionTaskRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelConversionTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelConversionTaskResponseUnmarshaller.Instance;

            return Invoke<CancelConversionTaskResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelConversionTask operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelConversionTask operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelConversionTask
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelConversionTask">REST API Reference for CancelConversionTask Operation</seealso>
        public virtual IAsyncResult BeginCancelConversionTask(CancelConversionTaskRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelConversionTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelConversionTaskResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelConversionTask operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelConversionTask.</param>
        /// 
        /// <returns>Returns a  CancelConversionTaskResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelConversionTask">REST API Reference for CancelConversionTask Operation</seealso>
        public virtual CancelConversionTaskResponse EndCancelConversionTask(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelConversionTaskResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelExportTask

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelExportTask service method.</param>
        /// 
        /// <returns>The response from the CancelExportTask service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelExportTask">REST API Reference for CancelExportTask Operation</seealso>
        public virtual CancelExportTaskResponse CancelExportTask(CancelExportTaskRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelExportTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelExportTaskResponseUnmarshaller.Instance;

            return Invoke<CancelExportTaskResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelExportTask operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelExportTask operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelExportTask
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelExportTask">REST API Reference for CancelExportTask Operation</seealso>
        public virtual IAsyncResult BeginCancelExportTask(CancelExportTaskRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelExportTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelExportTaskResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelExportTask operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelExportTask.</param>
        /// 
        /// <returns>Returns a  CancelExportTaskResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelExportTask">REST API Reference for CancelExportTask Operation</seealso>
        public virtual CancelExportTaskResponse EndCancelExportTask(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelExportTaskResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelImageLaunchPermission

        /// <summary>
        /// Removes your Amazon Web Services account from the launch permissions for the specified
        /// AMI. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cancel-sharing-an-AMI.html">
        /// Cancel having an AMI shared with your Amazon Web Services account</a> in the <i>Amazon
        /// EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelImageLaunchPermission service method.</param>
        /// 
        /// <returns>The response from the CancelImageLaunchPermission service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImageLaunchPermission">REST API Reference for CancelImageLaunchPermission Operation</seealso>
        public virtual CancelImageLaunchPermissionResponse CancelImageLaunchPermission(CancelImageLaunchPermissionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelImageLaunchPermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelImageLaunchPermissionResponseUnmarshaller.Instance;

            return Invoke<CancelImageLaunchPermissionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelImageLaunchPermission operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelImageLaunchPermission operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelImageLaunchPermission
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImageLaunchPermission">REST API Reference for CancelImageLaunchPermission Operation</seealso>
        public virtual IAsyncResult BeginCancelImageLaunchPermission(CancelImageLaunchPermissionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelImageLaunchPermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelImageLaunchPermissionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelImageLaunchPermission operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelImageLaunchPermission.</param>
        /// 
        /// <returns>Returns a  CancelImageLaunchPermissionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImageLaunchPermission">REST API Reference for CancelImageLaunchPermission Operation</seealso>
        public virtual CancelImageLaunchPermissionResponse EndCancelImageLaunchPermission(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelImageLaunchPermissionResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelImportTask

        /// <summary>
        /// Cancels an in-process import virtual machine or import snapshot task.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelImportTask service method.</param>
        /// 
        /// <returns>The response from the CancelImportTask service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImportTask">REST API Reference for CancelImportTask Operation</seealso>
        public virtual CancelImportTaskResponse CancelImportTask(CancelImportTaskRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelImportTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelImportTaskResponseUnmarshaller.Instance;

            return Invoke<CancelImportTaskResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelImportTask operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelImportTask operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelImportTask
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImportTask">REST API Reference for CancelImportTask Operation</seealso>
        public virtual IAsyncResult BeginCancelImportTask(CancelImportTaskRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelImportTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelImportTaskResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelImportTask operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelImportTask.</param>
        /// 
        /// <returns>Returns a  CancelImportTaskResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelImportTask">REST API Reference for CancelImportTask Operation</seealso>
        public virtual CancelImportTaskResponse EndCancelImportTask(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelImportTaskResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelReservedInstancesListing

        /// <summary>
        /// Cancels the specified Reserved Instance listing in the Reserved Instance Marketplace.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Reserved
        /// Instance Marketplace</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelReservedInstancesListing service method.</param>
        /// 
        /// <returns>The response from the CancelReservedInstancesListing service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelReservedInstancesListing">REST API Reference for CancelReservedInstancesListing Operation</seealso>
        public virtual CancelReservedInstancesListingResponse CancelReservedInstancesListing(CancelReservedInstancesListingRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelReservedInstancesListingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelReservedInstancesListingResponseUnmarshaller.Instance;

            return Invoke<CancelReservedInstancesListingResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelReservedInstancesListing operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelReservedInstancesListing operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelReservedInstancesListing
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelReservedInstancesListing">REST API Reference for CancelReservedInstancesListing Operation</seealso>
        public virtual IAsyncResult BeginCancelReservedInstancesListing(CancelReservedInstancesListingRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelReservedInstancesListingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelReservedInstancesListingResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelReservedInstancesListing operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelReservedInstancesListing.</param>
        /// 
        /// <returns>Returns a  CancelReservedInstancesListingResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelReservedInstancesListing">REST API Reference for CancelReservedInstancesListing Operation</seealso>
        public virtual CancelReservedInstancesListingResponse EndCancelReservedInstancesListing(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelReservedInstancesListingResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelSpotFleetRequests

        /// <summary>
        /// Cancels the specified Spot Fleet requests.
        /// 
        ///  
        /// <para>
        /// After you cancel a Spot Fleet request, the Spot Fleet launches no new instances.
        /// </para>
        ///  
        /// <para>
        /// You must also specify whether a canceled Spot Fleet request should terminate its instances.
        /// If you choose to terminate the instances, the Spot Fleet request enters the <code>cancelled_terminating</code>
        /// state. Otherwise, the Spot Fleet request enters the <code>cancelled_running</code>
        /// state and the instances continue to run until they are interrupted or you terminate
        /// them manually.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelSpotFleetRequests service method.</param>
        /// 
        /// <returns>The response from the CancelSpotFleetRequests service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotFleetRequests">REST API Reference for CancelSpotFleetRequests Operation</seealso>
        public virtual CancelSpotFleetRequestsResponse CancelSpotFleetRequests(CancelSpotFleetRequestsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelSpotFleetRequestsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelSpotFleetRequestsResponseUnmarshaller.Instance;

            return Invoke<CancelSpotFleetRequestsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelSpotFleetRequests operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelSpotFleetRequests operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelSpotFleetRequests
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotFleetRequests">REST API Reference for CancelSpotFleetRequests Operation</seealso>
        public virtual IAsyncResult BeginCancelSpotFleetRequests(CancelSpotFleetRequestsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelSpotFleetRequestsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelSpotFleetRequestsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelSpotFleetRequests operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelSpotFleetRequests.</param>
        /// 
        /// <returns>Returns a  CancelSpotFleetRequestsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotFleetRequests">REST API Reference for CancelSpotFleetRequests Operation</seealso>
        public virtual CancelSpotFleetRequestsResponse EndCancelSpotFleetRequests(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelSpotFleetRequestsResponse>(asyncResult);
        }

        #endregion
        
        #region  CancelSpotInstanceRequests

        /// <summary>
        /// Cancels one or more Spot Instance requests.
        /// 
        ///  <important> 
        /// <para>
        /// Canceling a Spot Instance request does not terminate running Spot Instances associated
        /// with the request.
        /// </para>
        ///  </important>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CancelSpotInstanceRequests service method.</param>
        /// 
        /// <returns>The response from the CancelSpotInstanceRequests service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotInstanceRequests">REST API Reference for CancelSpotInstanceRequests Operation</seealso>
        public virtual CancelSpotInstanceRequestsResponse CancelSpotInstanceRequests(CancelSpotInstanceRequestsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelSpotInstanceRequestsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelSpotInstanceRequestsResponseUnmarshaller.Instance;

            return Invoke<CancelSpotInstanceRequestsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CancelSpotInstanceRequests operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CancelSpotInstanceRequests operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelSpotInstanceRequests
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotInstanceRequests">REST API Reference for CancelSpotInstanceRequests Operation</seealso>
        public virtual IAsyncResult BeginCancelSpotInstanceRequests(CancelSpotInstanceRequestsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CancelSpotInstanceRequestsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CancelSpotInstanceRequestsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CancelSpotInstanceRequests operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCancelSpotInstanceRequests.</param>
        /// 
        /// <returns>Returns a  CancelSpotInstanceRequestsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CancelSpotInstanceRequests">REST API Reference for CancelSpotInstanceRequests Operation</seealso>
        public virtual CancelSpotInstanceRequestsResponse EndCancelSpotInstanceRequests(IAsyncResult asyncResult)
        {
            return EndInvoke<CancelSpotInstanceRequestsResponse>(asyncResult);
        }

        #endregion
        
        #region  ConfirmProductInstance

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ConfirmProductInstance service method.</param>
        /// 
        /// <returns>The response from the ConfirmProductInstance service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ConfirmProductInstance">REST API Reference for ConfirmProductInstance Operation</seealso>
        public virtual ConfirmProductInstanceResponse ConfirmProductInstance(ConfirmProductInstanceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ConfirmProductInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ConfirmProductInstanceResponseUnmarshaller.Instance;

            return Invoke<ConfirmProductInstanceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ConfirmProductInstance operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ConfirmProductInstance operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndConfirmProductInstance
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ConfirmProductInstance">REST API Reference for ConfirmProductInstance Operation</seealso>
        public virtual IAsyncResult BeginConfirmProductInstance(ConfirmProductInstanceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ConfirmProductInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ConfirmProductInstanceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ConfirmProductInstance operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginConfirmProductInstance.</param>
        /// 
        /// <returns>Returns a  ConfirmProductInstanceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ConfirmProductInstance">REST API Reference for ConfirmProductInstance Operation</seealso>
        public virtual ConfirmProductInstanceResponse EndConfirmProductInstance(IAsyncResult asyncResult)
        {
            return EndInvoke<ConfirmProductInstanceResponse>(asyncResult);
        }

        #endregion
        
        #region  CopyFpgaImage

        /// <summary>
        /// Copies the specified Amazon FPGA Image (AFI) to the current Region.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CopyFpgaImage service method.</param>
        /// 
        /// <returns>The response from the CopyFpgaImage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyFpgaImage">REST API Reference for CopyFpgaImage Operation</seealso>
        public virtual CopyFpgaImageResponse CopyFpgaImage(CopyFpgaImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CopyFpgaImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CopyFpgaImageResponseUnmarshaller.Instance;

            return Invoke<CopyFpgaImageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CopyFpgaImage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CopyFpgaImage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCopyFpgaImage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyFpgaImage">REST API Reference for CopyFpgaImage Operation</seealso>
        public virtual IAsyncResult BeginCopyFpgaImage(CopyFpgaImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CopyFpgaImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CopyFpgaImageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CopyFpgaImage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCopyFpgaImage.</param>
        /// 
        /// <returns>Returns a  CopyFpgaImageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyFpgaImage">REST API Reference for CopyFpgaImage Operation</seealso>
        public virtual CopyFpgaImageResponse EndCopyFpgaImage(IAsyncResult asyncResult)
        {
            return EndInvoke<CopyFpgaImageResponse>(asyncResult);
        }

        #endregion
        
        #region  CopyImage

        /// <summary>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateStoreImageTask.html">CreateStoreImageTask</a>.
        /// 
        ///  
        /// <para>
        /// To copy an AMI from one Region to another, specify the source Region using the <b>SourceRegion</b>
        /// 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 <code>Encrypted</code> during the copy operation.
        /// You cannot create an unencrypted copy of an encrypted backing snapshot.
        /// </para>
        ///  
        /// <para>
        /// To copy an AMI from a Region to an Outpost, specify the source Region using the <b>SourceRegion</b>
        /// parameter, and specify the ARN of the destination Outpost using <b>DestinationOutpostArn</b>.
        /// 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 <b>KmsKeyId</b>. Outposts do not support unencrypted snapshots. For more information,
        /// <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/snapshots-outposts.html#ami">
        /// Amazon EBS local snapshots on Outposts</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// For more information about the prerequisites and limits when copying an AMI, see <a
        /// href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html">Copy an
        /// AMI</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CopyImage service method.</param>
        /// 
        /// <returns>The response from the CopyImage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyImage">REST API Reference for CopyImage Operation</seealso>
        public virtual CopyImageResponse CopyImage(CopyImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CopyImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CopyImageResponseUnmarshaller.Instance;

            return Invoke<CopyImageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CopyImage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CopyImage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCopyImage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyImage">REST API Reference for CopyImage Operation</seealso>
        public virtual IAsyncResult BeginCopyImage(CopyImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CopyImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CopyImageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CopyImage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCopyImage.</param>
        /// 
        /// <returns>Returns a  CopyImageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopyImage">REST API Reference for CopyImage Operation</seealso>
        public virtual CopyImageResponse EndCopyImage(IAsyncResult asyncResult)
        {
            return EndInvoke<CopyImageResponse>(asyncResult);
        }

        #endregion
        
        #region  CopySnapshot

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// You can use the snapshot to create EBS volumes or Amazon Machine Images (AMIs).
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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 <b>KmsKeyId</b>.
        /// Outposts do not support unencrypted snapshots. For more information, <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/snapshots-outposts.html#ami">
        /// Amazon EBS local snapshots on Outposts</a> in the <i>Amazon Elastic Compute Cloud
        /// User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// Snapshots created by copying another snapshot have an arbitrary volume ID that should
        /// not be used for any purpose.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-copy-snapshot.html">Copy
        /// an Amazon EBS snapshot</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CopySnapshot service method.</param>
        /// 
        /// <returns>The response from the CopySnapshot service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopySnapshot">REST API Reference for CopySnapshot Operation</seealso>
        public virtual CopySnapshotResponse CopySnapshot(CopySnapshotRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance;

            return Invoke<CopySnapshotResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CopySnapshot operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CopySnapshot operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCopySnapshot
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopySnapshot">REST API Reference for CopySnapshot Operation</seealso>
        public virtual IAsyncResult BeginCopySnapshot(CopySnapshotRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CopySnapshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CopySnapshotResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CopySnapshot operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCopySnapshot.</param>
        /// 
        /// <returns>Returns a  CopySnapshotResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CopySnapshot">REST API Reference for CopySnapshot Operation</seealso>
        public virtual CopySnapshotResponse EndCopySnapshot(IAsyncResult asyncResult)
        {
            return EndInvoke<CopySnapshotResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateCapacityReservation

        /// <summary>
        /// Creates a new Capacity Reservation with the specified attributes.
        /// 
        ///  
        /// <para>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-capacity-reservations.html">Capacity
        /// Reservations</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-resource-limits.html">Amazon
        /// EC2 Service Quotas</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateCapacityReservation service method.</param>
        /// 
        /// <returns>The response from the CreateCapacityReservation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityReservation">REST API Reference for CreateCapacityReservation Operation</seealso>
        public virtual CreateCapacityReservationResponse CreateCapacityReservation(CreateCapacityReservationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCapacityReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCapacityReservationResponseUnmarshaller.Instance;

            return Invoke<CreateCapacityReservationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateCapacityReservation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateCapacityReservation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCapacityReservation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityReservation">REST API Reference for CreateCapacityReservation Operation</seealso>
        public virtual IAsyncResult BeginCreateCapacityReservation(CreateCapacityReservationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCapacityReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCapacityReservationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateCapacityReservation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateCapacityReservation.</param>
        /// 
        /// <returns>Returns a  CreateCapacityReservationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityReservation">REST API Reference for CreateCapacityReservation Operation</seealso>
        public virtual CreateCapacityReservationResponse EndCreateCapacityReservation(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateCapacityReservationResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateCapacityReservationFleet

        /// <summary>
        /// Creates a Capacity Reservation Fleet. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/work-with-cr-fleets.html#create-crfleet">Create
        /// a Capacity Reservation Fleet</a> in the Amazon EC2 User Guide.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateCapacityReservationFleet service method.</param>
        /// 
        /// <returns>The response from the CreateCapacityReservationFleet service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityReservationFleet">REST API Reference for CreateCapacityReservationFleet Operation</seealso>
        public virtual CreateCapacityReservationFleetResponse CreateCapacityReservationFleet(CreateCapacityReservationFleetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCapacityReservationFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCapacityReservationFleetResponseUnmarshaller.Instance;

            return Invoke<CreateCapacityReservationFleetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateCapacityReservationFleet operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateCapacityReservationFleet operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCapacityReservationFleet
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityReservationFleet">REST API Reference for CreateCapacityReservationFleet Operation</seealso>
        public virtual IAsyncResult BeginCreateCapacityReservationFleet(CreateCapacityReservationFleetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCapacityReservationFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCapacityReservationFleetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateCapacityReservationFleet operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateCapacityReservationFleet.</param>
        /// 
        /// <returns>Returns a  CreateCapacityReservationFleetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCapacityReservationFleet">REST API Reference for CreateCapacityReservationFleet Operation</seealso>
        public virtual CreateCapacityReservationFleetResponse EndCreateCapacityReservationFleet(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateCapacityReservationFleetResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateCarrierGateway

        /// <summary>
        /// Creates a carrier gateway. For more information about carrier gateways, see <a href="https://docs.aws.amazon.com/wavelength/latest/developerguide/how-wavelengths-work.html#wavelength-carrier-gateway">Carrier
        /// gateways</a> in the <i>Amazon Web Services Wavelength Developer Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateCarrierGateway service method.</param>
        /// 
        /// <returns>The response from the CreateCarrierGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCarrierGateway">REST API Reference for CreateCarrierGateway Operation</seealso>
        public virtual CreateCarrierGatewayResponse CreateCarrierGateway(CreateCarrierGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCarrierGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCarrierGatewayResponseUnmarshaller.Instance;

            return Invoke<CreateCarrierGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateCarrierGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateCarrierGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCarrierGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCarrierGateway">REST API Reference for CreateCarrierGateway Operation</seealso>
        public virtual IAsyncResult BeginCreateCarrierGateway(CreateCarrierGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCarrierGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCarrierGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateCarrierGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateCarrierGateway.</param>
        /// 
        /// <returns>Returns a  CreateCarrierGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCarrierGateway">REST API Reference for CreateCarrierGateway Operation</seealso>
        public virtual CreateCarrierGatewayResponse EndCreateCarrierGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateCarrierGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateClientVpnEndpoint

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateClientVpnEndpoint service method.</param>
        /// 
        /// <returns>The response from the CreateClientVpnEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateClientVpnEndpoint">REST API Reference for CreateClientVpnEndpoint Operation</seealso>
        public virtual CreateClientVpnEndpointResponse CreateClientVpnEndpoint(CreateClientVpnEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateClientVpnEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateClientVpnEndpointResponseUnmarshaller.Instance;

            return Invoke<CreateClientVpnEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateClientVpnEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateClientVpnEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateClientVpnEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateClientVpnEndpoint">REST API Reference for CreateClientVpnEndpoint Operation</seealso>
        public virtual IAsyncResult BeginCreateClientVpnEndpoint(CreateClientVpnEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateClientVpnEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateClientVpnEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateClientVpnEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateClientVpnEndpoint.</param>
        /// 
        /// <returns>Returns a  CreateClientVpnEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateClientVpnEndpoint">REST API Reference for CreateClientVpnEndpoint Operation</seealso>
        public virtual CreateClientVpnEndpointResponse EndCreateClientVpnEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateClientVpnEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateClientVpnRoute

        /// <summary>
        /// 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 traffic to specific resources or networks.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateClientVpnRoute service method.</param>
        /// 
        /// <returns>The response from the CreateClientVpnRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateClientVpnRoute">REST API Reference for CreateClientVpnRoute Operation</seealso>
        public virtual CreateClientVpnRouteResponse CreateClientVpnRoute(CreateClientVpnRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateClientVpnRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateClientVpnRouteResponseUnmarshaller.Instance;

            return Invoke<CreateClientVpnRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateClientVpnRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateClientVpnRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateClientVpnRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateClientVpnRoute">REST API Reference for CreateClientVpnRoute Operation</seealso>
        public virtual IAsyncResult BeginCreateClientVpnRoute(CreateClientVpnRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateClientVpnRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateClientVpnRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateClientVpnRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateClientVpnRoute.</param>
        /// 
        /// <returns>Returns a  CreateClientVpnRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateClientVpnRoute">REST API Reference for CreateClientVpnRoute Operation</seealso>
        public virtual CreateClientVpnRouteResponse EndCreateClientVpnRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateClientVpnRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateCoipCidr

        /// <summary>
        /// Creates a range of customer-owned IP addresses.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateCoipCidr service method.</param>
        /// 
        /// <returns>The response from the CreateCoipCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCoipCidr">REST API Reference for CreateCoipCidr Operation</seealso>
        public virtual CreateCoipCidrResponse CreateCoipCidr(CreateCoipCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCoipCidrResponseUnmarshaller.Instance;

            return Invoke<CreateCoipCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateCoipCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateCoipCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCoipCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCoipCidr">REST API Reference for CreateCoipCidr Operation</seealso>
        public virtual IAsyncResult BeginCreateCoipCidr(CreateCoipCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCoipCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateCoipCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateCoipCidr.</param>
        /// 
        /// <returns>Returns a  CreateCoipCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCoipCidr">REST API Reference for CreateCoipCidr Operation</seealso>
        public virtual CreateCoipCidrResponse EndCreateCoipCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateCoipCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateCoipPool

        /// <summary>
        /// Creates a pool of customer-owned IP (CoIP) addresses.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateCoipPool service method.</param>
        /// 
        /// <returns>The response from the CreateCoipPool service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCoipPool">REST API Reference for CreateCoipPool Operation</seealso>
        public virtual CreateCoipPoolResponse CreateCoipPool(CreateCoipPoolRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCoipPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCoipPoolResponseUnmarshaller.Instance;

            return Invoke<CreateCoipPoolResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateCoipPool operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateCoipPool operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCoipPool
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCoipPool">REST API Reference for CreateCoipPool Operation</seealso>
        public virtual IAsyncResult BeginCreateCoipPool(CreateCoipPoolRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCoipPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCoipPoolResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateCoipPool operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateCoipPool.</param>
        /// 
        /// <returns>Returns a  CreateCoipPoolResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCoipPool">REST API Reference for CreateCoipPool Operation</seealso>
        public virtual CreateCoipPoolResponse EndCreateCoipPool(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateCoipPoolResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateCustomerGateway

        /// <summary>
        /// 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).
        /// 
        ///  
        /// <para>
        /// For devices that use Border Gateway Protocol (BGP), you can also provide the device's
        /// BGP Autonomous System Number (ASN). You can use an existing ASN assigned to your network.
        /// If you don't have an ASN already, you can use a private ASN. For more information,
        /// see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/cgw-options.html">Customer
        /// gateway options for your Site-to-Site VPN connection</a> in the <i>Amazon Web Services
        /// Site-to-Site VPN User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateCustomerGateway service method.</param>
        /// 
        /// <returns>The response from the CreateCustomerGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCustomerGateway">REST API Reference for CreateCustomerGateway Operation</seealso>
        public virtual CreateCustomerGatewayResponse CreateCustomerGateway(CreateCustomerGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCustomerGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCustomerGatewayResponseUnmarshaller.Instance;

            return Invoke<CreateCustomerGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateCustomerGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateCustomerGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateCustomerGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCustomerGateway">REST API Reference for CreateCustomerGateway Operation</seealso>
        public virtual IAsyncResult BeginCreateCustomerGateway(CreateCustomerGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateCustomerGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateCustomerGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateCustomerGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateCustomerGateway.</param>
        /// 
        /// <returns>Returns a  CreateCustomerGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateCustomerGateway">REST API Reference for CreateCustomerGateway Operation</seealso>
        public virtual CreateCustomerGatewayResponse EndCreateCustomerGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateCustomerGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateDefaultSubnet

        /// <summary>
        /// Creates a default subnet with a size <code>/20</code> IPv4 CIDR block in the specified
        /// Availability Zone in your default VPC. You can have only one default subnet per Availability
        /// Zone. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#create-default-subnet">Create
        /// a default subnet</a> in the <i>Amazon VPC User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateDefaultSubnet service method.</param>
        /// 
        /// <returns>The response from the CreateDefaultSubnet service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDefaultSubnet">REST API Reference for CreateDefaultSubnet Operation</seealso>
        public virtual CreateDefaultSubnetResponse CreateDefaultSubnet(CreateDefaultSubnetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateDefaultSubnetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateDefaultSubnetResponseUnmarshaller.Instance;

            return Invoke<CreateDefaultSubnetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateDefaultSubnet operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateDefaultSubnet operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDefaultSubnet
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDefaultSubnet">REST API Reference for CreateDefaultSubnet Operation</seealso>
        public virtual IAsyncResult BeginCreateDefaultSubnet(CreateDefaultSubnetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateDefaultSubnetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateDefaultSubnetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateDefaultSubnet operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateDefaultSubnet.</param>
        /// 
        /// <returns>Returns a  CreateDefaultSubnetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDefaultSubnet">REST API Reference for CreateDefaultSubnet Operation</seealso>
        public virtual CreateDefaultSubnetResponse EndCreateDefaultSubnet(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateDefaultSubnetResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateDefaultVpc

        /// <summary>
        /// Creates a default VPC with a size <code>/16</code> IPv4 CIDR block and a default subnet
        /// in each Availability Zone. For more information about the components of a default
        /// VPC, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html">Default
        /// VPCs</a> in the <i>Amazon VPC User Guide</i>. You cannot specify the components of
        /// the default VPC yourself.
        /// 
        ///  
        /// <para>
        /// If you deleted your previous default VPC, you can create a default VPC. You cannot
        /// have more than one default VPC per Region.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateDefaultVpc service method.</param>
        /// 
        /// <returns>The response from the CreateDefaultVpc service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDefaultVpc">REST API Reference for CreateDefaultVpc Operation</seealso>
        public virtual CreateDefaultVpcResponse CreateDefaultVpc(CreateDefaultVpcRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateDefaultVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateDefaultVpcResponseUnmarshaller.Instance;

            return Invoke<CreateDefaultVpcResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateDefaultVpc operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateDefaultVpc operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDefaultVpc
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDefaultVpc">REST API Reference for CreateDefaultVpc Operation</seealso>
        public virtual IAsyncResult BeginCreateDefaultVpc(CreateDefaultVpcRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateDefaultVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateDefaultVpcResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateDefaultVpc operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateDefaultVpc.</param>
        /// 
        /// <returns>Returns a  CreateDefaultVpcResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDefaultVpc">REST API Reference for CreateDefaultVpc Operation</seealso>
        public virtual CreateDefaultVpcResponse EndCreateDefaultVpc(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateDefaultVpcResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateDhcpOptions

        /// <summary>
        /// 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 <a href="http://www.ietf.org/rfc/rfc2132.txt">RFC
        /// 2132</a>.
        /// 
        ///  <ul> <li> 
        /// <para>
        ///  <code>domain-name-servers</code> - 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 <code>domain-name</code>, you must set <code>domain-name-servers</code>
        /// to a custom DNS server.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>domain-name</code> - If you're using AmazonProvidedDNS in <code>us-east-1</code>,
        /// specify <code>ec2.internal</code>. If you're using AmazonProvidedDNS in another Region,
        /// specify <code>region.compute.internal</code> (for example, <code>ap-northeast-1.compute.internal</code>).
        /// Otherwise, specify a domain name (for example, <code>ExampleCompany.com</code>). This
        /// value is used to complete unqualified DNS hostnames. <b>Important</b>: 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.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>ntp-servers</code> - The IP addresses of up to four Network Time Protocol (NTP)
        /// servers.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>netbios-name-servers</code> - The IP addresses of up to four NetBIOS name servers.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>netbios-node-type</code> - The NetBIOS node type (1, 2, 4, or 8). We recommend
        /// that you specify 2 (broadcast and multicast are not currently supported). For more
        /// information about these node types, see <a href="http://www.ietf.org/rfc/rfc2132.txt">RFC
        /// 2132</a>.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// 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 <code>domain-name-servers</code>
        /// option either to <code>AmazonProvidedDNS</code> or to a domain name server of your
        /// choice. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP
        /// options sets</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateDhcpOptions service method.</param>
        /// 
        /// <returns>The response from the CreateDhcpOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDhcpOptions">REST API Reference for CreateDhcpOptions Operation</seealso>
        public virtual CreateDhcpOptionsResponse CreateDhcpOptions(CreateDhcpOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateDhcpOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateDhcpOptionsResponseUnmarshaller.Instance;

            return Invoke<CreateDhcpOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateDhcpOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateDhcpOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDhcpOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDhcpOptions">REST API Reference for CreateDhcpOptions Operation</seealso>
        public virtual IAsyncResult BeginCreateDhcpOptions(CreateDhcpOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateDhcpOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateDhcpOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateDhcpOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateDhcpOptions.</param>
        /// 
        /// <returns>Returns a  CreateDhcpOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateDhcpOptions">REST API Reference for CreateDhcpOptions Operation</seealso>
        public virtual CreateDhcpOptionsResponse EndCreateDhcpOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateDhcpOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateEgressOnlyInternetGateway

        /// <summary>
        /// [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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateEgressOnlyInternetGateway service method.</param>
        /// 
        /// <returns>The response from the CreateEgressOnlyInternetGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateEgressOnlyInternetGateway">REST API Reference for CreateEgressOnlyInternetGateway Operation</seealso>
        public virtual CreateEgressOnlyInternetGatewayResponse CreateEgressOnlyInternetGateway(CreateEgressOnlyInternetGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateEgressOnlyInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateEgressOnlyInternetGatewayResponseUnmarshaller.Instance;

            return Invoke<CreateEgressOnlyInternetGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateEgressOnlyInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateEgressOnlyInternetGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateEgressOnlyInternetGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateEgressOnlyInternetGateway">REST API Reference for CreateEgressOnlyInternetGateway Operation</seealso>
        public virtual IAsyncResult BeginCreateEgressOnlyInternetGateway(CreateEgressOnlyInternetGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateEgressOnlyInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateEgressOnlyInternetGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateEgressOnlyInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateEgressOnlyInternetGateway.</param>
        /// 
        /// <returns>Returns a  CreateEgressOnlyInternetGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateEgressOnlyInternetGateway">REST API Reference for CreateEgressOnlyInternetGateway Operation</seealso>
        public virtual CreateEgressOnlyInternetGatewayResponse EndCreateEgressOnlyInternetGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateEgressOnlyInternetGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateFleet

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// A single EC2 Fleet can include multiple launch specifications that vary by instance
        /// type, AMI, Availability Zone, or subnet.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet.html">EC2
        /// Fleet</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateFleet service method.</param>
        /// 
        /// <returns>The response from the CreateFleet service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFleet">REST API Reference for CreateFleet Operation</seealso>
        public virtual CreateFleetResponse CreateFleet(CreateFleetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateFleetResponseUnmarshaller.Instance;

            return Invoke<CreateFleetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateFleet operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateFleet operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateFleet
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFleet">REST API Reference for CreateFleet Operation</seealso>
        public virtual IAsyncResult BeginCreateFleet(CreateFleetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateFleetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateFleet operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateFleet.</param>
        /// 
        /// <returns>Returns a  CreateFleetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFleet">REST API Reference for CreateFleet Operation</seealso>
        public virtual CreateFleetResponse EndCreateFleet(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateFleetResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateFlowLogs

        /// <summary>
        /// Creates one or more flow logs to capture information about IP traffic for a specific
        /// network interface, subnet, or VPC. 
        /// 
        ///  
        /// <para>
        /// Flow log data for a monitored network interface is recorded as flow log records, which
        /// are log events consisting of fields that describe the traffic flow. For more information,
        /// see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records">Flow
        /// log records</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html">VPC
        /// Flow Logs</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateFlowLogs service method.</param>
        /// 
        /// <returns>The response from the CreateFlowLogs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFlowLogs">REST API Reference for CreateFlowLogs Operation</seealso>
        public virtual CreateFlowLogsResponse CreateFlowLogs(CreateFlowLogsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateFlowLogsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateFlowLogsResponseUnmarshaller.Instance;

            return Invoke<CreateFlowLogsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateFlowLogs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateFlowLogs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateFlowLogs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFlowLogs">REST API Reference for CreateFlowLogs Operation</seealso>
        public virtual IAsyncResult BeginCreateFlowLogs(CreateFlowLogsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateFlowLogsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateFlowLogsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateFlowLogs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateFlowLogs.</param>
        /// 
        /// <returns>Returns a  CreateFlowLogsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFlowLogs">REST API Reference for CreateFlowLogs Operation</seealso>
        public virtual CreateFlowLogsResponse EndCreateFlowLogs(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateFlowLogsResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateFpgaImage

        /// <summary>
        /// Creates an Amazon FPGA Image (AFI) from the specified design checkpoint (DCP).
        /// 
        ///  
        /// <para>
        /// The create operation is asynchronous. To verify that the AFI is ready for use, check
        /// the output logs.
        /// </para>
        ///  
        /// <para>
        /// An AFI contains the FPGA bitstream that is ready to download to an FPGA. You can securely
        /// deploy an AFI on multiple FPGA-accelerated instances. For more information, see the
        /// <a href="https://github.com/aws/aws-fpga/">Amazon Web Services FPGA Hardware Development
        /// Kit</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateFpgaImage service method.</param>
        /// 
        /// <returns>The response from the CreateFpgaImage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFpgaImage">REST API Reference for CreateFpgaImage Operation</seealso>
        public virtual CreateFpgaImageResponse CreateFpgaImage(CreateFpgaImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateFpgaImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateFpgaImageResponseUnmarshaller.Instance;

            return Invoke<CreateFpgaImageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateFpgaImage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateFpgaImage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateFpgaImage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFpgaImage">REST API Reference for CreateFpgaImage Operation</seealso>
        public virtual IAsyncResult BeginCreateFpgaImage(CreateFpgaImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateFpgaImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateFpgaImageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateFpgaImage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateFpgaImage.</param>
        /// 
        /// <returns>Returns a  CreateFpgaImageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateFpgaImage">REST API Reference for CreateFpgaImage Operation</seealso>
        public virtual CreateFpgaImageResponse EndCreateFpgaImage(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateFpgaImageResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateImage

        /// <summary>
        /// Creates an Amazon EBS-backed AMI from an Amazon EBS-backed instance that is either
        /// running or stopped.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html">Create
        /// an Amazon EBS-backed Linux AMI</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateImage service method.</param>
        /// 
        /// <returns>The response from the CreateImage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateImage">REST API Reference for CreateImage Operation</seealso>
        public virtual CreateImageResponse CreateImage(CreateImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateImageResponseUnmarshaller.Instance;

            return Invoke<CreateImageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateImage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateImage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateImage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateImage">REST API Reference for CreateImage Operation</seealso>
        public virtual IAsyncResult BeginCreateImage(CreateImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateImageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateImage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateImage.</param>
        /// 
        /// <returns>Returns a  CreateImageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateImage">REST API Reference for CreateImage Operation</seealso>
        public virtual CreateImageResponse EndCreateImage(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateImageResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateInstanceConnectEndpoint

        /// <summary>
        /// Creates an EC2 Instance Connect Endpoint.
        /// 
        ///  
        /// <para>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Connect-using-EC2-Instance-Connect-Endpoint.html">Connect
        /// to your instances without requiring a public IPv4 address using EC2 Instance Connect
        /// Endpoint</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateInstanceConnectEndpoint service method.</param>
        /// 
        /// <returns>The response from the CreateInstanceConnectEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceConnectEndpoint">REST API Reference for CreateInstanceConnectEndpoint Operation</seealso>
        public virtual CreateInstanceConnectEndpointResponse CreateInstanceConnectEndpoint(CreateInstanceConnectEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateInstanceConnectEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateInstanceConnectEndpointResponseUnmarshaller.Instance;

            return Invoke<CreateInstanceConnectEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateInstanceConnectEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateInstanceConnectEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateInstanceConnectEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceConnectEndpoint">REST API Reference for CreateInstanceConnectEndpoint Operation</seealso>
        public virtual IAsyncResult BeginCreateInstanceConnectEndpoint(CreateInstanceConnectEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateInstanceConnectEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateInstanceConnectEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateInstanceConnectEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateInstanceConnectEndpoint.</param>
        /// 
        /// <returns>Returns a  CreateInstanceConnectEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceConnectEndpoint">REST API Reference for CreateInstanceConnectEndpoint Operation</seealso>
        public virtual CreateInstanceConnectEndpointResponse EndCreateInstanceConnectEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateInstanceConnectEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateInstanceEventWindow

        /// <summary>
        /// Creates an event window in which scheduled events for the associated Amazon EC2 instances
        /// can run.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// You can create up to 200 event windows per Amazon Web Services Region.
        /// </para>
        ///  
        /// <para>
        /// When you create the event window, targets (instance IDs, Dedicated Host IDs, or tags)
        /// are not yet associated with it. To ensure that the event window can be used, you must
        /// associate one or more targets with it by using the <a>AssociateInstanceEventWindow</a>
        /// API.
        /// </para>
        ///  <important> 
        /// <para>
        /// Event windows are applicable only for scheduled events that stop, reboot, or terminate
        /// instances.
        /// </para>
        ///  
        /// <para>
        /// Event windows are <i>not</i> applicable for:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        /// Expedited scheduled events and network maintenance events. 
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Unscheduled maintenance such as AutoRecovery and unplanned reboots.
        /// </para>
        ///  </li> </ul> </important> 
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
        /// event windows for scheduled events</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateInstanceEventWindow service method.</param>
        /// 
        /// <returns>The response from the CreateInstanceEventWindow service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceEventWindow">REST API Reference for CreateInstanceEventWindow Operation</seealso>
        public virtual CreateInstanceEventWindowResponse CreateInstanceEventWindow(CreateInstanceEventWindowRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateInstanceEventWindowResponseUnmarshaller.Instance;

            return Invoke<CreateInstanceEventWindowResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateInstanceEventWindow operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateInstanceEventWindow
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceEventWindow">REST API Reference for CreateInstanceEventWindow Operation</seealso>
        public virtual IAsyncResult BeginCreateInstanceEventWindow(CreateInstanceEventWindowRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateInstanceEventWindowResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateInstanceEventWindow.</param>
        /// 
        /// <returns>Returns a  CreateInstanceEventWindowResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceEventWindow">REST API Reference for CreateInstanceEventWindow Operation</seealso>
        public virtual CreateInstanceEventWindowResponse EndCreateInstanceEventWindow(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateInstanceEventWindowResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateInstanceExportTask

        /// <summary>
        /// Exports a running or stopped instance to an Amazon S3 bucket.
        /// 
        ///  
        /// <para>
        /// For information about the prerequisites for your Amazon S3 bucket, supported operating
        /// systems, image formats, and known limitations for the types of instances you can export,
        /// see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport.html">Exporting
        /// an instance as a VM Using VM Import/Export</a> in the <i>VM Import/Export User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateInstanceExportTask service method.</param>
        /// 
        /// <returns>The response from the CreateInstanceExportTask service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceExportTask">REST API Reference for CreateInstanceExportTask Operation</seealso>
        public virtual CreateInstanceExportTaskResponse CreateInstanceExportTask(CreateInstanceExportTaskRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateInstanceExportTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateInstanceExportTaskResponseUnmarshaller.Instance;

            return Invoke<CreateInstanceExportTaskResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateInstanceExportTask operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateInstanceExportTask operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateInstanceExportTask
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceExportTask">REST API Reference for CreateInstanceExportTask Operation</seealso>
        public virtual IAsyncResult BeginCreateInstanceExportTask(CreateInstanceExportTaskRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateInstanceExportTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateInstanceExportTaskResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateInstanceExportTask operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateInstanceExportTask.</param>
        /// 
        /// <returns>Returns a  CreateInstanceExportTaskResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInstanceExportTask">REST API Reference for CreateInstanceExportTask Operation</seealso>
        public virtual CreateInstanceExportTaskResponse EndCreateInstanceExportTask(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateInstanceExportTaskResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateInternetGateway

        /// <summary>
        /// Creates an internet gateway for use with a VPC. After creating the internet gateway,
        /// you attach it to a VPC using <a>AttachInternetGateway</a>.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html">Internet
        /// gateways</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the CreateInternetGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInternetGateway">REST API Reference for CreateInternetGateway Operation</seealso>
        public virtual CreateInternetGatewayResponse CreateInternetGateway()
        {
            return CreateInternetGateway(new CreateInternetGatewayRequest());
        }

        /// <summary>
        /// Creates an internet gateway for use with a VPC. After creating the internet gateway,
        /// you attach it to a VPC using <a>AttachInternetGateway</a>.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html">Internet
        /// gateways</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateInternetGateway service method.</param>
        /// 
        /// <returns>The response from the CreateInternetGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInternetGateway">REST API Reference for CreateInternetGateway Operation</seealso>
        public virtual CreateInternetGatewayResponse CreateInternetGateway(CreateInternetGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateInternetGatewayResponseUnmarshaller.Instance;

            return Invoke<CreateInternetGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateInternetGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateInternetGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInternetGateway">REST API Reference for CreateInternetGateway Operation</seealso>
        public virtual IAsyncResult BeginCreateInternetGateway(CreateInternetGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateInternetGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateInternetGateway.</param>
        /// 
        /// <returns>Returns a  CreateInternetGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateInternetGateway">REST API Reference for CreateInternetGateway Operation</seealso>
        public virtual CreateInternetGatewayResponse EndCreateInternetGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateInternetGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateIpam

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/create-ipam.html">Create
        /// an IPAM</a> in the <i>Amazon VPC IPAM User Guide</i>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateIpam service method.</param>
        /// 
        /// <returns>The response from the CreateIpam service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpam">REST API Reference for CreateIpam Operation</seealso>
        public virtual CreateIpamResponse CreateIpam(CreateIpamRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpamRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpamResponseUnmarshaller.Instance;

            return Invoke<CreateIpamResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateIpam operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateIpam operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateIpam
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpam">REST API Reference for CreateIpam Operation</seealso>
        public virtual IAsyncResult BeginCreateIpam(CreateIpamRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpamRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpamResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateIpam operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateIpam.</param>
        /// 
        /// <returns>Returns a  CreateIpamResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpam">REST API Reference for CreateIpam Operation</seealso>
        public virtual CreateIpamResponse EndCreateIpam(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateIpamResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateIpamPool

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/create-top-ipam.html">Create
        /// a top-level pool</a> in the <i>Amazon VPC IPAM User Guide</i>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateIpamPool service method.</param>
        /// 
        /// <returns>The response from the CreateIpamPool service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamPool">REST API Reference for CreateIpamPool Operation</seealso>
        public virtual CreateIpamPoolResponse CreateIpamPool(CreateIpamPoolRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpamPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpamPoolResponseUnmarshaller.Instance;

            return Invoke<CreateIpamPoolResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateIpamPool operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateIpamPool operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateIpamPool
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamPool">REST API Reference for CreateIpamPool Operation</seealso>
        public virtual IAsyncResult BeginCreateIpamPool(CreateIpamPoolRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpamPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpamPoolResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateIpamPool operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateIpamPool.</param>
        /// 
        /// <returns>Returns a  CreateIpamPoolResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamPool">REST API Reference for CreateIpamPool Operation</seealso>
        public virtual CreateIpamPoolResponse EndCreateIpamPool(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateIpamPoolResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateIpamResourceDiscovery

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateIpamResourceDiscovery service method.</param>
        /// 
        /// <returns>The response from the CreateIpamResourceDiscovery service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamResourceDiscovery">REST API Reference for CreateIpamResourceDiscovery Operation</seealso>
        public virtual CreateIpamResourceDiscoveryResponse CreateIpamResourceDiscovery(CreateIpamResourceDiscoveryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return Invoke<CreateIpamResourceDiscoveryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateIpamResourceDiscovery operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateIpamResourceDiscovery
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamResourceDiscovery">REST API Reference for CreateIpamResourceDiscovery Operation</seealso>
        public virtual IAsyncResult BeginCreateIpamResourceDiscovery(CreateIpamResourceDiscoveryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateIpamResourceDiscovery.</param>
        /// 
        /// <returns>Returns a  CreateIpamResourceDiscoveryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamResourceDiscovery">REST API Reference for CreateIpamResourceDiscovery Operation</seealso>
        public virtual CreateIpamResourceDiscoveryResponse EndCreateIpamResourceDiscovery(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateIpamResourceDiscoveryResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateIpamScope

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/add-scope-ipam.html">Add
        /// a scope</a> in the <i>Amazon VPC IPAM User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateIpamScope service method.</param>
        /// 
        /// <returns>The response from the CreateIpamScope service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamScope">REST API Reference for CreateIpamScope Operation</seealso>
        public virtual CreateIpamScopeResponse CreateIpamScope(CreateIpamScopeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpamScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpamScopeResponseUnmarshaller.Instance;

            return Invoke<CreateIpamScopeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateIpamScope operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateIpamScope operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateIpamScope
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamScope">REST API Reference for CreateIpamScope Operation</seealso>
        public virtual IAsyncResult BeginCreateIpamScope(CreateIpamScopeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateIpamScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateIpamScopeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateIpamScope operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateIpamScope.</param>
        /// 
        /// <returns>Returns a  CreateIpamScopeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateIpamScope">REST API Reference for CreateIpamScope Operation</seealso>
        public virtual CreateIpamScopeResponse EndCreateIpamScope(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateIpamScopeResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateKeyPair

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// The key pair returned to you is available only in the Amazon Web Services Region in
        /// which you create it. If you prefer, you can create your own key pair using a third-party
        /// tool and upload it to any Region using <a>ImportKeyPair</a>.
        /// </para>
        ///  
        /// <para>
        /// You can have up to 5,000 key pairs per Amazon Web Services Region.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Amazon
        /// EC2 key pairs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateKeyPair service method.</param>
        /// 
        /// <returns>The response from the CreateKeyPair service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateKeyPair">REST API Reference for CreateKeyPair Operation</seealso>
        public virtual CreateKeyPairResponse CreateKeyPair(CreateKeyPairRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateKeyPairRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateKeyPairResponseUnmarshaller.Instance;

            return Invoke<CreateKeyPairResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateKeyPair operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateKeyPair operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateKeyPair
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateKeyPair">REST API Reference for CreateKeyPair Operation</seealso>
        public virtual IAsyncResult BeginCreateKeyPair(CreateKeyPairRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateKeyPairRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateKeyPairResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateKeyPair operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateKeyPair.</param>
        /// 
        /// <returns>Returns a  CreateKeyPairResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateKeyPair">REST API Reference for CreateKeyPair Operation</seealso>
        public virtual CreateKeyPairResponse EndCreateKeyPair(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateKeyPairResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateLaunchTemplate

        /// <summary>
        /// Creates a launch template.
        /// 
        ///  
        /// <para>
        /// A launch template contains the parameters to launch an instance. When you launch an
        /// instance using <a>RunInstances</a>, you can specify a launch template instead of providing
        /// the launch parameters in the request. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">Launch
        /// an instance from a launch template</a> in the <i>Amazon Elastic Compute Cloud User
        /// Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#create-launch-template-from-existing-launch-template">Create
        /// a launch template from an existing launch template</a> in the <i>Amazon Elastic Compute
        /// Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateLaunchTemplate service method.</param>
        /// 
        /// <returns>The response from the CreateLaunchTemplate service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLaunchTemplate">REST API Reference for CreateLaunchTemplate Operation</seealso>
        public virtual CreateLaunchTemplateResponse CreateLaunchTemplate(CreateLaunchTemplateRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLaunchTemplateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLaunchTemplateResponseUnmarshaller.Instance;

            return Invoke<CreateLaunchTemplateResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateLaunchTemplate operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateLaunchTemplate operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLaunchTemplate
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLaunchTemplate">REST API Reference for CreateLaunchTemplate Operation</seealso>
        public virtual IAsyncResult BeginCreateLaunchTemplate(CreateLaunchTemplateRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLaunchTemplateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLaunchTemplateResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateLaunchTemplate operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateLaunchTemplate.</param>
        /// 
        /// <returns>Returns a  CreateLaunchTemplateResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLaunchTemplate">REST API Reference for CreateLaunchTemplate Operation</seealso>
        public virtual CreateLaunchTemplateResponse EndCreateLaunchTemplate(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateLaunchTemplateResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateLaunchTemplateVersion

        /// <summary>
        /// Creates a new version of a launch template. You can specify an existing version of
        /// launch template from which to base the new version.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html#manage-launch-template-versions">Modify
        /// a launch template (manage launch template versions)</a> in the <i>Amazon Elastic Compute
        /// Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateLaunchTemplateVersion service method.</param>
        /// 
        /// <returns>The response from the CreateLaunchTemplateVersion service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLaunchTemplateVersion">REST API Reference for CreateLaunchTemplateVersion Operation</seealso>
        public virtual CreateLaunchTemplateVersionResponse CreateLaunchTemplateVersion(CreateLaunchTemplateVersionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLaunchTemplateVersionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLaunchTemplateVersionResponseUnmarshaller.Instance;

            return Invoke<CreateLaunchTemplateVersionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateLaunchTemplateVersion operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateLaunchTemplateVersion operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLaunchTemplateVersion
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLaunchTemplateVersion">REST API Reference for CreateLaunchTemplateVersion Operation</seealso>
        public virtual IAsyncResult BeginCreateLaunchTemplateVersion(CreateLaunchTemplateVersionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLaunchTemplateVersionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLaunchTemplateVersionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateLaunchTemplateVersion operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateLaunchTemplateVersion.</param>
        /// 
        /// <returns>Returns a  CreateLaunchTemplateVersionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLaunchTemplateVersion">REST API Reference for CreateLaunchTemplateVersion Operation</seealso>
        public virtual CreateLaunchTemplateVersionResponse EndCreateLaunchTemplateVersion(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateLaunchTemplateVersionResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateLocalGatewayRoute

        /// <summary>
        /// Creates a static route for the specified local gateway route table. You must specify
        /// one of the following targets: 
        /// 
        ///  <ul> <li> 
        /// <para>
        ///  <code>LocalGatewayVirtualInterfaceGroupId</code> 
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>NetworkInterfaceId</code> 
        /// </para>
        ///  </li> </ul>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateLocalGatewayRoute service method.</param>
        /// 
        /// <returns>The response from the CreateLocalGatewayRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRoute">REST API Reference for CreateLocalGatewayRoute Operation</seealso>
        public virtual CreateLocalGatewayRouteResponse CreateLocalGatewayRoute(CreateLocalGatewayRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLocalGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLocalGatewayRouteResponseUnmarshaller.Instance;

            return Invoke<CreateLocalGatewayRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateLocalGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateLocalGatewayRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLocalGatewayRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRoute">REST API Reference for CreateLocalGatewayRoute Operation</seealso>
        public virtual IAsyncResult BeginCreateLocalGatewayRoute(CreateLocalGatewayRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLocalGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLocalGatewayRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateLocalGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateLocalGatewayRoute.</param>
        /// 
        /// <returns>Returns a  CreateLocalGatewayRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRoute">REST API Reference for CreateLocalGatewayRoute Operation</seealso>
        public virtual CreateLocalGatewayRouteResponse EndCreateLocalGatewayRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateLocalGatewayRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateLocalGatewayRouteTable

        /// <summary>
        /// Creates a local gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateLocalGatewayRouteTable service method.</param>
        /// 
        /// <returns>The response from the CreateLocalGatewayRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTable">REST API Reference for CreateLocalGatewayRouteTable Operation</seealso>
        public virtual CreateLocalGatewayRouteTableResponse CreateLocalGatewayRouteTable(CreateLocalGatewayRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLocalGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLocalGatewayRouteTableResponseUnmarshaller.Instance;

            return Invoke<CreateLocalGatewayRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateLocalGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateLocalGatewayRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLocalGatewayRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTable">REST API Reference for CreateLocalGatewayRouteTable Operation</seealso>
        public virtual IAsyncResult BeginCreateLocalGatewayRouteTable(CreateLocalGatewayRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLocalGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLocalGatewayRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateLocalGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateLocalGatewayRouteTable.</param>
        /// 
        /// <returns>Returns a  CreateLocalGatewayRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTable">REST API Reference for CreateLocalGatewayRouteTable Operation</seealso>
        public virtual CreateLocalGatewayRouteTableResponse EndCreateLocalGatewayRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateLocalGatewayRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation

        /// <summary>
        /// Creates a local gateway route table virtual interface group association.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation service method.</param>
        /// 
        /// <returns>The response from the CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation">REST API Reference for CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation Operation</seealso>
        public virtual CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponse CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseUnmarshaller.Instance;

            return Invoke<CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation">REST API Reference for CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation Operation</seealso>
        public virtual IAsyncResult BeginCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation.</param>
        /// 
        /// <returns>Returns a  CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation">REST API Reference for CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation Operation</seealso>
        public virtual CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponse EndCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateLocalGatewayRouteTableVpcAssociation

        /// <summary>
        /// Associates the specified VPC with the specified local gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateLocalGatewayRouteTableVpcAssociation service method.</param>
        /// 
        /// <returns>The response from the CreateLocalGatewayRouteTableVpcAssociation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTableVpcAssociation">REST API Reference for CreateLocalGatewayRouteTableVpcAssociation Operation</seealso>
        public virtual CreateLocalGatewayRouteTableVpcAssociationResponse CreateLocalGatewayRouteTableVpcAssociation(CreateLocalGatewayRouteTableVpcAssociationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLocalGatewayRouteTableVpcAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLocalGatewayRouteTableVpcAssociationResponseUnmarshaller.Instance;

            return Invoke<CreateLocalGatewayRouteTableVpcAssociationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateLocalGatewayRouteTableVpcAssociation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateLocalGatewayRouteTableVpcAssociation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLocalGatewayRouteTableVpcAssociation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTableVpcAssociation">REST API Reference for CreateLocalGatewayRouteTableVpcAssociation Operation</seealso>
        public virtual IAsyncResult BeginCreateLocalGatewayRouteTableVpcAssociation(CreateLocalGatewayRouteTableVpcAssociationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateLocalGatewayRouteTableVpcAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateLocalGatewayRouteTableVpcAssociationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateLocalGatewayRouteTableVpcAssociation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateLocalGatewayRouteTableVpcAssociation.</param>
        /// 
        /// <returns>Returns a  CreateLocalGatewayRouteTableVpcAssociationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateLocalGatewayRouteTableVpcAssociation">REST API Reference for CreateLocalGatewayRouteTableVpcAssociation Operation</seealso>
        public virtual CreateLocalGatewayRouteTableVpcAssociationResponse EndCreateLocalGatewayRouteTableVpcAssociation(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateLocalGatewayRouteTableVpcAssociationResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateManagedPrefixList

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateManagedPrefixList service method.</param>
        /// 
        /// <returns>The response from the CreateManagedPrefixList service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateManagedPrefixList">REST API Reference for CreateManagedPrefixList Operation</seealso>
        public virtual CreateManagedPrefixListResponse CreateManagedPrefixList(CreateManagedPrefixListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateManagedPrefixListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateManagedPrefixListResponseUnmarshaller.Instance;

            return Invoke<CreateManagedPrefixListResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateManagedPrefixList operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateManagedPrefixList operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateManagedPrefixList
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateManagedPrefixList">REST API Reference for CreateManagedPrefixList Operation</seealso>
        public virtual IAsyncResult BeginCreateManagedPrefixList(CreateManagedPrefixListRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateManagedPrefixListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateManagedPrefixListResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateManagedPrefixList operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateManagedPrefixList.</param>
        /// 
        /// <returns>Returns a  CreateManagedPrefixListResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateManagedPrefixList">REST API Reference for CreateManagedPrefixList Operation</seealso>
        public virtual CreateManagedPrefixListResponse EndCreateManagedPrefixList(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateManagedPrefixListResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateNatGateway

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html">NAT
        /// gateways</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateNatGateway service method.</param>
        /// 
        /// <returns>The response from the CreateNatGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNatGateway">REST API Reference for CreateNatGateway Operation</seealso>
        public virtual CreateNatGatewayResponse CreateNatGateway(CreateNatGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNatGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNatGatewayResponseUnmarshaller.Instance;

            return Invoke<CreateNatGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateNatGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateNatGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateNatGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNatGateway">REST API Reference for CreateNatGateway Operation</seealso>
        public virtual IAsyncResult BeginCreateNatGateway(CreateNatGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNatGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNatGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateNatGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateNatGateway.</param>
        /// 
        /// <returns>Returns a  CreateNatGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNatGateway">REST API Reference for CreateNatGateway Operation</seealso>
        public virtual CreateNatGatewayResponse EndCreateNatGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateNatGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateNetworkAcl

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
        /// ACLs</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkAcl service method.</param>
        /// 
        /// <returns>The response from the CreateNetworkAcl service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAcl">REST API Reference for CreateNetworkAcl Operation</seealso>
        public virtual CreateNetworkAclResponse CreateNetworkAcl(CreateNetworkAclRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkAclRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkAclResponseUnmarshaller.Instance;

            return Invoke<CreateNetworkAclResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateNetworkAcl operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkAcl operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateNetworkAcl
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAcl">REST API Reference for CreateNetworkAcl Operation</seealso>
        public virtual IAsyncResult BeginCreateNetworkAcl(CreateNetworkAclRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkAclRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkAclResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateNetworkAcl operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateNetworkAcl.</param>
        /// 
        /// <returns>Returns a  CreateNetworkAclResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAcl">REST API Reference for CreateNetworkAcl Operation</seealso>
        public virtual CreateNetworkAclResponse EndCreateNetworkAcl(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateNetworkAclResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateNetworkAclEntry

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// After you add an entry, you can't modify it; you must either replace it, or create
        /// an entry and delete the old one.
        /// </para>
        ///  
        /// <para>
        /// For more information about network ACLs, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
        /// ACLs</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkAclEntry service method.</param>
        /// 
        /// <returns>The response from the CreateNetworkAclEntry service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAclEntry">REST API Reference for CreateNetworkAclEntry Operation</seealso>
        public virtual CreateNetworkAclEntryResponse CreateNetworkAclEntry(CreateNetworkAclEntryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkAclEntryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkAclEntryResponseUnmarshaller.Instance;

            return Invoke<CreateNetworkAclEntryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateNetworkAclEntry operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkAclEntry operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateNetworkAclEntry
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAclEntry">REST API Reference for CreateNetworkAclEntry Operation</seealso>
        public virtual IAsyncResult BeginCreateNetworkAclEntry(CreateNetworkAclEntryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkAclEntryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkAclEntryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateNetworkAclEntry operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateNetworkAclEntry.</param>
        /// 
        /// <returns>Returns a  CreateNetworkAclEntryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkAclEntry">REST API Reference for CreateNetworkAclEntry Operation</seealso>
        public virtual CreateNetworkAclEntryResponse EndCreateNetworkAclEntry(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateNetworkAclEntryResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateNetworkInsightsAccessScope

        /// <summary>
        /// Creates a Network Access Scope.
        /// 
        ///  
        /// <para>
        /// Amazon Web Services Network Access Analyzer enables cloud networking and cloud operations
        /// teams to verify that their networks on Amazon Web Services conform to their network
        /// security and governance objectives. For more information, see the <a href="https://docs.aws.amazon.com/vpc/latest/network-access-analyzer/">Amazon
        /// Web Services Network Access Analyzer Guide</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkInsightsAccessScope service method.</param>
        /// 
        /// <returns>The response from the CreateNetworkInsightsAccessScope service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInsightsAccessScope">REST API Reference for CreateNetworkInsightsAccessScope Operation</seealso>
        public virtual CreateNetworkInsightsAccessScopeResponse CreateNetworkInsightsAccessScope(CreateNetworkInsightsAccessScopeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkInsightsAccessScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkInsightsAccessScopeResponseUnmarshaller.Instance;

            return Invoke<CreateNetworkInsightsAccessScopeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateNetworkInsightsAccessScope operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkInsightsAccessScope operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateNetworkInsightsAccessScope
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInsightsAccessScope">REST API Reference for CreateNetworkInsightsAccessScope Operation</seealso>
        public virtual IAsyncResult BeginCreateNetworkInsightsAccessScope(CreateNetworkInsightsAccessScopeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkInsightsAccessScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkInsightsAccessScopeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateNetworkInsightsAccessScope operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateNetworkInsightsAccessScope.</param>
        /// 
        /// <returns>Returns a  CreateNetworkInsightsAccessScopeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInsightsAccessScope">REST API Reference for CreateNetworkInsightsAccessScope Operation</seealso>
        public virtual CreateNetworkInsightsAccessScopeResponse EndCreateNetworkInsightsAccessScope(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateNetworkInsightsAccessScopeResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateNetworkInsightsPath

        /// <summary>
        /// Creates a path to analyze for reachability.
        /// 
        ///  
        /// <para>
        /// Reachability Analyzer enables you to analyze and debug network reachability between
        /// two resources in your virtual private cloud (VPC). For more information, see the <a
        /// href="https://docs.aws.amazon.com/vpc/latest/reachability/">Reachability Analyzer
        /// Guide</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkInsightsPath service method.</param>
        /// 
        /// <returns>The response from the CreateNetworkInsightsPath service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInsightsPath">REST API Reference for CreateNetworkInsightsPath Operation</seealso>
        public virtual CreateNetworkInsightsPathResponse CreateNetworkInsightsPath(CreateNetworkInsightsPathRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkInsightsPathRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkInsightsPathResponseUnmarshaller.Instance;

            return Invoke<CreateNetworkInsightsPathResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateNetworkInsightsPath operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkInsightsPath operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateNetworkInsightsPath
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInsightsPath">REST API Reference for CreateNetworkInsightsPath Operation</seealso>
        public virtual IAsyncResult BeginCreateNetworkInsightsPath(CreateNetworkInsightsPathRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkInsightsPathRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkInsightsPathResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateNetworkInsightsPath operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateNetworkInsightsPath.</param>
        /// 
        /// <returns>Returns a  CreateNetworkInsightsPathResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInsightsPath">REST API Reference for CreateNetworkInsightsPath Operation</seealso>
        public virtual CreateNetworkInsightsPathResponse EndCreateNetworkInsightsPath(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateNetworkInsightsPathResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateNetworkInterface

        /// <summary>
        /// Creates a network interface in the specified subnet.
        /// 
        ///  
        /// <para>
        /// The number of IP addresses you can assign to a network interface varies by instance
        /// type. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html#AvailableIpPerENI">IP
        /// Addresses Per ENI Per Instance Type</a> in the <i>Amazon Virtual Private Cloud User
        /// Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// For more information about network interfaces, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html">Elastic
        /// network interfaces</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkInterface service method.</param>
        /// 
        /// <returns>The response from the CreateNetworkInterface service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterface">REST API Reference for CreateNetworkInterface Operation</seealso>
        public virtual CreateNetworkInterfaceResponse CreateNetworkInterface(CreateNetworkInterfaceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkInterfaceResponseUnmarshaller.Instance;

            return Invoke<CreateNetworkInterfaceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateNetworkInterface operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkInterface operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateNetworkInterface
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterface">REST API Reference for CreateNetworkInterface Operation</seealso>
        public virtual IAsyncResult BeginCreateNetworkInterface(CreateNetworkInterfaceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkInterfaceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateNetworkInterface operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateNetworkInterface.</param>
        /// 
        /// <returns>Returns a  CreateNetworkInterfaceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterface">REST API Reference for CreateNetworkInterface Operation</seealso>
        public virtual CreateNetworkInterfaceResponse EndCreateNetworkInterface(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateNetworkInterfaceResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateNetworkInterfacePermission

        /// <summary>
        /// Grants an Amazon Web Services-authorized account permission to attach the specified
        /// network interface to an instance in their account.
        /// 
        ///  
        /// <para>
        /// You can grant permission to a single Amazon Web Services account only, and only one
        /// account at a time.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkInterfacePermission service method.</param>
        /// 
        /// <returns>The response from the CreateNetworkInterfacePermission service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterfacePermission">REST API Reference for CreateNetworkInterfacePermission Operation</seealso>
        public virtual CreateNetworkInterfacePermissionResponse CreateNetworkInterfacePermission(CreateNetworkInterfacePermissionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkInterfacePermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkInterfacePermissionResponseUnmarshaller.Instance;

            return Invoke<CreateNetworkInterfacePermissionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateNetworkInterfacePermission operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateNetworkInterfacePermission operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateNetworkInterfacePermission
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterfacePermission">REST API Reference for CreateNetworkInterfacePermission Operation</seealso>
        public virtual IAsyncResult BeginCreateNetworkInterfacePermission(CreateNetworkInterfacePermissionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateNetworkInterfacePermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateNetworkInterfacePermissionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateNetworkInterfacePermission operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateNetworkInterfacePermission.</param>
        /// 
        /// <returns>Returns a  CreateNetworkInterfacePermissionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateNetworkInterfacePermission">REST API Reference for CreateNetworkInterfacePermission Operation</seealso>
        public virtual CreateNetworkInterfacePermissionResponse EndCreateNetworkInterfacePermission(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateNetworkInterfacePermissionResponse>(asyncResult);
        }

        #endregion
        
        #region  CreatePlacementGroup

        /// <summary>
        /// Creates a placement group in which to launch instances. The strategy of the placement
        /// group determines how the instances are organized within the group. 
        /// 
        ///  
        /// <para>
        /// A <code>cluster</code> placement group is a logical grouping of instances within a
        /// single Availability Zone that benefit from low network latency, high network throughput.
        /// A <code>spread</code> placement group places instances on distinct hardware. A <code>partition</code>
        /// placement group places groups of instances in different partitions, where instances
        /// in one partition do not share the same hardware with instances in another partition.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">Placement
        /// groups</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreatePlacementGroup service method.</param>
        /// 
        /// <returns>The response from the CreatePlacementGroup service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePlacementGroup">REST API Reference for CreatePlacementGroup Operation</seealso>
        public virtual CreatePlacementGroupResponse CreatePlacementGroup(CreatePlacementGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreatePlacementGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreatePlacementGroupResponseUnmarshaller.Instance;

            return Invoke<CreatePlacementGroupResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreatePlacementGroup operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreatePlacementGroup operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreatePlacementGroup
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePlacementGroup">REST API Reference for CreatePlacementGroup Operation</seealso>
        public virtual IAsyncResult BeginCreatePlacementGroup(CreatePlacementGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreatePlacementGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreatePlacementGroupResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreatePlacementGroup operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreatePlacementGroup.</param>
        /// 
        /// <returns>Returns a  CreatePlacementGroupResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePlacementGroup">REST API Reference for CreatePlacementGroup Operation</seealso>
        public virtual CreatePlacementGroupResponse EndCreatePlacementGroup(IAsyncResult asyncResult)
        {
            return EndInvoke<CreatePlacementGroupResponse>(asyncResult);
        }

        #endregion
        
        #region  CreatePublicIpv4Pool

        /// <summary>
        /// Creates a public IPv4 address pool. A public IPv4 pool is an EC2 IP address pool required
        /// for the public IPv4 CIDRs that you own and bring to Amazon Web Services to manage
        /// with IPAM. IPv6 addresses you bring to Amazon Web Services, however, use IPAM pools
        /// only. To monitor the status of pool creation, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribePublicIpv4Pools.html">DescribePublicIpv4Pools</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreatePublicIpv4Pool service method.</param>
        /// 
        /// <returns>The response from the CreatePublicIpv4Pool service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePublicIpv4Pool">REST API Reference for CreatePublicIpv4Pool Operation</seealso>
        public virtual CreatePublicIpv4PoolResponse CreatePublicIpv4Pool(CreatePublicIpv4PoolRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreatePublicIpv4PoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreatePublicIpv4PoolResponseUnmarshaller.Instance;

            return Invoke<CreatePublicIpv4PoolResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreatePublicIpv4Pool operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreatePublicIpv4Pool operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreatePublicIpv4Pool
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePublicIpv4Pool">REST API Reference for CreatePublicIpv4Pool Operation</seealso>
        public virtual IAsyncResult BeginCreatePublicIpv4Pool(CreatePublicIpv4PoolRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreatePublicIpv4PoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreatePublicIpv4PoolResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreatePublicIpv4Pool operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreatePublicIpv4Pool.</param>
        /// 
        /// <returns>Returns a  CreatePublicIpv4PoolResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreatePublicIpv4Pool">REST API Reference for CreatePublicIpv4Pool Operation</seealso>
        public virtual CreatePublicIpv4PoolResponse EndCreatePublicIpv4Pool(IAsyncResult asyncResult)
        {
            return EndInvoke<CreatePublicIpv4PoolResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateReplaceRootVolumeTask

        /// <summary>
        /// Replaces the EBS-backed root volume for a <code>running</code> instance with a new
        /// volume that is restored to the original root volume's launch state, that is restored
        /// to a specific snapshot taken from the original root volume, or that is restored from
        /// an AMI that has the same key characteristics as that of the instance.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/replace-root.html">Replace
        /// a root volume</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateReplaceRootVolumeTask service method.</param>
        /// 
        /// <returns>The response from the CreateReplaceRootVolumeTask service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReplaceRootVolumeTask">REST API Reference for CreateReplaceRootVolumeTask Operation</seealso>
        public virtual CreateReplaceRootVolumeTaskResponse CreateReplaceRootVolumeTask(CreateReplaceRootVolumeTaskRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateReplaceRootVolumeTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateReplaceRootVolumeTaskResponseUnmarshaller.Instance;

            return Invoke<CreateReplaceRootVolumeTaskResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateReplaceRootVolumeTask operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateReplaceRootVolumeTask operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateReplaceRootVolumeTask
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReplaceRootVolumeTask">REST API Reference for CreateReplaceRootVolumeTask Operation</seealso>
        public virtual IAsyncResult BeginCreateReplaceRootVolumeTask(CreateReplaceRootVolumeTaskRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateReplaceRootVolumeTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateReplaceRootVolumeTaskResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateReplaceRootVolumeTask operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateReplaceRootVolumeTask.</param>
        /// 
        /// <returns>Returns a  CreateReplaceRootVolumeTaskResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReplaceRootVolumeTask">REST API Reference for CreateReplaceRootVolumeTask Operation</seealso>
        public virtual CreateReplaceRootVolumeTaskResponse EndCreateReplaceRootVolumeTask(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateReplaceRootVolumeTaskResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateReservedInstancesListing

        /// <summary>
        /// Creates a listing for Amazon EC2 Standard Reserved Instances to be sold in the Reserved
        /// Instance Marketplace. You can submit one Standard Reserved Instance listing at a time.
        /// To get a list of your Standard Reserved Instances, you can use the <a>DescribeReservedInstances</a>
        /// operation.
        /// 
        ///  <note> 
        /// <para>
        /// Only Standard Reserved Instances can be sold in the Reserved Instance Marketplace.
        /// Convertible Reserved Instances cannot be sold.
        /// </para>
        ///  </note> 
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// To sell your Standard Reserved Instances, you must first register as a seller in the
        /// Reserved Instance Marketplace. After completing the registration process, you can
        /// create a Reserved Instance Marketplace listing of some or all of your Standard Reserved
        /// Instances, and specify the upfront price to receive for them. Your Standard Reserved
        /// Instance listings then become available for purchase. To view the details of your
        /// Standard Reserved Instance listing, you can use the <a>DescribeReservedInstancesListings</a>
        /// operation.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Reserved
        /// Instance Marketplace</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateReservedInstancesListing service method.</param>
        /// 
        /// <returns>The response from the CreateReservedInstancesListing service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReservedInstancesListing">REST API Reference for CreateReservedInstancesListing Operation</seealso>
        public virtual CreateReservedInstancesListingResponse CreateReservedInstancesListing(CreateReservedInstancesListingRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateReservedInstancesListingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateReservedInstancesListingResponseUnmarshaller.Instance;

            return Invoke<CreateReservedInstancesListingResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateReservedInstancesListing operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateReservedInstancesListing operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateReservedInstancesListing
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReservedInstancesListing">REST API Reference for CreateReservedInstancesListing Operation</seealso>
        public virtual IAsyncResult BeginCreateReservedInstancesListing(CreateReservedInstancesListingRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateReservedInstancesListingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateReservedInstancesListingResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateReservedInstancesListing operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateReservedInstancesListing.</param>
        /// 
        /// <returns>Returns a  CreateReservedInstancesListingResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateReservedInstancesListing">REST API Reference for CreateReservedInstancesListing Operation</seealso>
        public virtual CreateReservedInstancesListingResponse EndCreateReservedInstancesListing(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateReservedInstancesListingResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateRestoreImageTask

        /// <summary>
        /// Starts a task that restores an AMI from an Amazon S3 object that was previously created
        /// by using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateStoreImageTask.html">CreateStoreImageTask</a>.
        /// 
        ///  
        /// <para>
        /// To use this API, you must have the required permissions. For more information, see
        /// <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html#ami-s3-permissions">Permissions
        /// for storing and restoring AMIs using Amazon S3</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html">Store
        /// and restore an AMI using Amazon S3</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateRestoreImageTask service method.</param>
        /// 
        /// <returns>The response from the CreateRestoreImageTask service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRestoreImageTask">REST API Reference for CreateRestoreImageTask Operation</seealso>
        public virtual CreateRestoreImageTaskResponse CreateRestoreImageTask(CreateRestoreImageTaskRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateRestoreImageTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateRestoreImageTaskResponseUnmarshaller.Instance;

            return Invoke<CreateRestoreImageTaskResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateRestoreImageTask operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateRestoreImageTask operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateRestoreImageTask
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRestoreImageTask">REST API Reference for CreateRestoreImageTask Operation</seealso>
        public virtual IAsyncResult BeginCreateRestoreImageTask(CreateRestoreImageTaskRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateRestoreImageTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateRestoreImageTaskResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateRestoreImageTask operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateRestoreImageTask.</param>
        /// 
        /// <returns>Returns a  CreateRestoreImageTaskResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRestoreImageTask">REST API Reference for CreateRestoreImageTask Operation</seealso>
        public virtual CreateRestoreImageTaskResponse EndCreateRestoreImageTask(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateRestoreImageTaskResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateRoute

        /// <summary>
        /// Creates a route in a route table within a VPC.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// When determining how to route traffic, we use the route with the most specific match.
        /// For example, traffic is destined for the IPv4 address <code>192.0.2.3</code>, and
        /// the route table includes the following two IPv4 routes:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        ///  <code>192.0.2.0/24</code> (goes to some target A)
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>192.0.2.0/28</code> (goes to some target B)
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// Both routes apply to the traffic destined for <code>192.0.2.3</code>. However, the
        /// second route in the list covers a smaller number of IP addresses and is therefore
        /// more specific, so we use that route to determine where to target the traffic.
        /// </para>
        ///  
        /// <para>
        /// For more information about route tables, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
        /// tables</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateRoute service method.</param>
        /// 
        /// <returns>The response from the CreateRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRoute">REST API Reference for CreateRoute Operation</seealso>
        public virtual CreateRouteResponse CreateRoute(CreateRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateRouteResponseUnmarshaller.Instance;

            return Invoke<CreateRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRoute">REST API Reference for CreateRoute Operation</seealso>
        public virtual IAsyncResult BeginCreateRoute(CreateRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateRoute.</param>
        /// 
        /// <returns>Returns a  CreateRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRoute">REST API Reference for CreateRoute Operation</seealso>
        public virtual CreateRouteResponse EndCreateRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateRouteTable

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
        /// tables</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateRouteTable service method.</param>
        /// 
        /// <returns>The response from the CreateRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRouteTable">REST API Reference for CreateRouteTable Operation</seealso>
        public virtual CreateRouteTableResponse CreateRouteTable(CreateRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateRouteTableResponseUnmarshaller.Instance;

            return Invoke<CreateRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRouteTable">REST API Reference for CreateRouteTable Operation</seealso>
        public virtual IAsyncResult BeginCreateRouteTable(CreateRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateRouteTable.</param>
        /// 
        /// <returns>Returns a  CreateRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateRouteTable">REST API Reference for CreateRouteTable Operation</seealso>
        public virtual CreateRouteTableResponse EndCreateRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateSecurityGroup

        /// <summary>
        /// Creates a security group.
        /// 
        ///  
        /// <para>
        /// A security group acts as a virtual firewall for your instance to control inbound and
        /// outbound traffic. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Amazon
        /// EC2 security groups</a> in the <i>Amazon Elastic Compute Cloud User Guide</i> and
        /// <a href="https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_SecurityGroups.html">Security
        /// groups for your VPC</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// You can add or remove rules from your security groups using <a>AuthorizeSecurityGroupIngress</a>,
        /// <a>AuthorizeSecurityGroupEgress</a>, <a>RevokeSecurityGroupIngress</a>, and <a>RevokeSecurityGroupEgress</a>.
        /// </para>
        ///  
        /// <para>
        /// For more information about VPC security group limits, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon
        /// VPC Limits</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateSecurityGroup service method.</param>
        /// 
        /// <returns>The response from the CreateSecurityGroup service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSecurityGroup">REST API Reference for CreateSecurityGroup Operation</seealso>
        public virtual CreateSecurityGroupResponse CreateSecurityGroup(CreateSecurityGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSecurityGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSecurityGroupResponseUnmarshaller.Instance;

            return Invoke<CreateSecurityGroupResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateSecurityGroup operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateSecurityGroup operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSecurityGroup
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSecurityGroup">REST API Reference for CreateSecurityGroup Operation</seealso>
        public virtual IAsyncResult BeginCreateSecurityGroup(CreateSecurityGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSecurityGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSecurityGroupResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateSecurityGroup operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateSecurityGroup.</param>
        /// 
        /// <returns>Returns a  CreateSecurityGroupResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSecurityGroup">REST API Reference for CreateSecurityGroup Operation</seealso>
        public virtual CreateSecurityGroupResponse EndCreateSecurityGroup(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateSecurityGroupResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateSnapshot

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// When a snapshot is created, any Amazon Web Services Marketplace product codes that
        /// are associated with the source volume are propagated to the snapshot.
        /// </para>
        ///  
        /// <para>
        /// You can take a snapshot of an attached volume that is in use. However, snapshots only
        /// capture data that has been written to your Amazon EBS volume at the time the snapshot
        /// command is issued; this might exclude any data that has been cached by any applications
        /// or the operating system. If you can pause any file systems on the volume long enough
        /// to take a snapshot, your snapshot should be complete. However, if you cannot pause
        /// all file writes to the volume, you should unmount the volume from within the instance,
        /// issue the snapshot command, and then remount the volume to ensure a consistent and
        /// complete snapshot. You may remount and use your volume while the snapshot status is
        /// <code>pending</code>.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// You can tag your snapshots during creation. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
        /// your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html">Amazon
        /// Elastic Block Store</a> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon
        /// EBS encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateSnapshot service method.</param>
        /// 
        /// <returns>The response from the CreateSnapshot service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshot">REST API Reference for CreateSnapshot Operation</seealso>
        public virtual CreateSnapshotResponse CreateSnapshot(CreateSnapshotRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance;

            return Invoke<CreateSnapshotResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateSnapshot operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateSnapshot operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSnapshot
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshot">REST API Reference for CreateSnapshot Operation</seealso>
        public virtual IAsyncResult BeginCreateSnapshot(CreateSnapshotRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateSnapshot operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateSnapshot.</param>
        /// 
        /// <returns>Returns a  CreateSnapshotResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshot">REST API Reference for CreateSnapshot Operation</seealso>
        public virtual CreateSnapshotResponse EndCreateSnapshot(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateSnapshotResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateSnapshots

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateSnapshots service method.</param>
        /// 
        /// <returns>The response from the CreateSnapshots service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshots">REST API Reference for CreateSnapshots Operation</seealso>
        public virtual CreateSnapshotsResponse CreateSnapshots(CreateSnapshotsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSnapshotsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSnapshotsResponseUnmarshaller.Instance;

            return Invoke<CreateSnapshotsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateSnapshots operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateSnapshots operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSnapshots
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshots">REST API Reference for CreateSnapshots Operation</seealso>
        public virtual IAsyncResult BeginCreateSnapshots(CreateSnapshotsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSnapshotsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSnapshotsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateSnapshots operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateSnapshots.</param>
        /// 
        /// <returns>Returns a  CreateSnapshotsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSnapshots">REST API Reference for CreateSnapshots Operation</seealso>
        public virtual CreateSnapshotsResponse EndCreateSnapshots(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateSnapshotsResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateSpotDatafeedSubscription

        /// <summary>
        /// Creates a data feed for Spot Instances, enabling you to view Spot Instance usage logs.
        /// You can create one data feed per Amazon Web Services account. For more information,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html">Spot
        /// Instance data feed</a> in the <i>Amazon EC2 User Guide for Linux Instances</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateSpotDatafeedSubscription service method.</param>
        /// 
        /// <returns>The response from the CreateSpotDatafeedSubscription service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSpotDatafeedSubscription">REST API Reference for CreateSpotDatafeedSubscription Operation</seealso>
        public virtual CreateSpotDatafeedSubscriptionResponse CreateSpotDatafeedSubscription(CreateSpotDatafeedSubscriptionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSpotDatafeedSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSpotDatafeedSubscriptionResponseUnmarshaller.Instance;

            return Invoke<CreateSpotDatafeedSubscriptionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateSpotDatafeedSubscription operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateSpotDatafeedSubscription operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSpotDatafeedSubscription
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSpotDatafeedSubscription">REST API Reference for CreateSpotDatafeedSubscription Operation</seealso>
        public virtual IAsyncResult BeginCreateSpotDatafeedSubscription(CreateSpotDatafeedSubscriptionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSpotDatafeedSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSpotDatafeedSubscriptionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateSpotDatafeedSubscription operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateSpotDatafeedSubscription.</param>
        /// 
        /// <returns>Returns a  CreateSpotDatafeedSubscriptionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSpotDatafeedSubscription">REST API Reference for CreateSpotDatafeedSubscription Operation</seealso>
        public virtual CreateSpotDatafeedSubscriptionResponse EndCreateSpotDatafeedSubscription(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateSpotDatafeedSubscriptionResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateStoreImageTask

        /// <summary>
        /// Stores an AMI as a single object in an Amazon S3 bucket.
        /// 
        ///  
        /// <para>
        /// To use this API, you must have the required permissions. For more information, see
        /// <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html#ami-s3-permissions">Permissions
        /// for storing and restoring AMIs using Amazon S3</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html">Store
        /// and restore an AMI using Amazon S3</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateStoreImageTask service method.</param>
        /// 
        /// <returns>The response from the CreateStoreImageTask service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateStoreImageTask">REST API Reference for CreateStoreImageTask Operation</seealso>
        public virtual CreateStoreImageTaskResponse CreateStoreImageTask(CreateStoreImageTaskRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateStoreImageTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateStoreImageTaskResponseUnmarshaller.Instance;

            return Invoke<CreateStoreImageTaskResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateStoreImageTask operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateStoreImageTask operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateStoreImageTask
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateStoreImageTask">REST API Reference for CreateStoreImageTask Operation</seealso>
        public virtual IAsyncResult BeginCreateStoreImageTask(CreateStoreImageTaskRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateStoreImageTaskRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateStoreImageTaskResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateStoreImageTask operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateStoreImageTask.</param>
        /// 
        /// <returns>Returns a  CreateStoreImageTaskResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateStoreImageTask">REST API Reference for CreateStoreImageTask Operation</seealso>
        public virtual CreateStoreImageTaskResponse EndCreateStoreImageTask(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateStoreImageTaskResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateSubnet

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/configure-subnets.html">Subnets</a>
        /// in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateSubnet service method.</param>
        /// 
        /// <returns>The response from the CreateSubnet service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnet">REST API Reference for CreateSubnet Operation</seealso>
        public virtual CreateSubnetResponse CreateSubnet(CreateSubnetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSubnetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSubnetResponseUnmarshaller.Instance;

            return Invoke<CreateSubnetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateSubnet operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateSubnet operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSubnet
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnet">REST API Reference for CreateSubnet Operation</seealso>
        public virtual IAsyncResult BeginCreateSubnet(CreateSubnetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSubnetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSubnetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateSubnet operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateSubnet.</param>
        /// 
        /// <returns>Returns a  CreateSubnetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnet">REST API Reference for CreateSubnet Operation</seealso>
        public virtual CreateSubnetResponse EndCreateSubnet(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateSubnetResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateSubnetCidrReservation

        /// <summary>
        /// Creates a subnet CIDR reservation. For information about subnet CIDR reservations,
        /// see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/subnet-cidr-reservation.html">Subnet
        /// CIDR reservations</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateSubnetCidrReservation service method.</param>
        /// 
        /// <returns>The response from the CreateSubnetCidrReservation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnetCidrReservation">REST API Reference for CreateSubnetCidrReservation Operation</seealso>
        public virtual CreateSubnetCidrReservationResponse CreateSubnetCidrReservation(CreateSubnetCidrReservationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSubnetCidrReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSubnetCidrReservationResponseUnmarshaller.Instance;

            return Invoke<CreateSubnetCidrReservationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateSubnetCidrReservation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateSubnetCidrReservation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSubnetCidrReservation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnetCidrReservation">REST API Reference for CreateSubnetCidrReservation Operation</seealso>
        public virtual IAsyncResult BeginCreateSubnetCidrReservation(CreateSubnetCidrReservationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateSubnetCidrReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateSubnetCidrReservationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateSubnetCidrReservation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateSubnetCidrReservation.</param>
        /// 
        /// <returns>Returns a  CreateSubnetCidrReservationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateSubnetCidrReservation">REST API Reference for CreateSubnetCidrReservation Operation</seealso>
        public virtual CreateSubnetCidrReservationResponse EndCreateSubnetCidrReservation(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateSubnetCidrReservationResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTags

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// For more information about tags, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
        /// your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// For more information about creating IAM policies that control users' access to resources
        /// based on tags, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-supported-iam-actions-resources.html">Supported
        /// resource-level permissions for Amazon EC2 API actions</a> in the <i>Amazon Elastic
        /// Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTags service method.</param>
        /// 
        /// <returns>The response from the CreateTags service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTags">REST API Reference for CreateTags Operation</seealso>
        public virtual CreateTagsResponse CreateTags(CreateTagsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTagsResponseUnmarshaller.Instance;

            return Invoke<CreateTagsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTags operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTags operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTags
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTags">REST API Reference for CreateTags Operation</seealso>
        public virtual IAsyncResult BeginCreateTags(CreateTagsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTagsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTags operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTags.</param>
        /// 
        /// <returns>Returns a  CreateTagsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTags">REST API Reference for CreateTags Operation</seealso>
        public virtual CreateTagsResponse EndCreateTags(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTagsResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTrafficMirrorFilter

        /// <summary>
        /// Creates a Traffic Mirror filter.
        /// 
        ///  
        /// <para>
        /// A Traffic Mirror filter is a set of rules that defines the traffic to mirror.
        /// </para>
        ///  
        /// <para>
        /// By default, no traffic is mirrored. To mirror traffic, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorFilterRule.htm">CreateTrafficMirrorFilterRule</a>
        /// to add Traffic Mirror rules to the filter. The rules you add define what traffic gets
        /// mirrored. You can also use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyTrafficMirrorFilterNetworkServices.html">ModifyTrafficMirrorFilterNetworkServices</a>
        /// to mirror supported network services.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTrafficMirrorFilter service method.</param>
        /// 
        /// <returns>The response from the CreateTrafficMirrorFilter service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorFilter">REST API Reference for CreateTrafficMirrorFilter Operation</seealso>
        public virtual CreateTrafficMirrorFilterResponse CreateTrafficMirrorFilter(CreateTrafficMirrorFilterRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTrafficMirrorFilterRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTrafficMirrorFilterResponseUnmarshaller.Instance;

            return Invoke<CreateTrafficMirrorFilterResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTrafficMirrorFilter operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTrafficMirrorFilter operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTrafficMirrorFilter
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorFilter">REST API Reference for CreateTrafficMirrorFilter Operation</seealso>
        public virtual IAsyncResult BeginCreateTrafficMirrorFilter(CreateTrafficMirrorFilterRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTrafficMirrorFilterRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTrafficMirrorFilterResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTrafficMirrorFilter operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTrafficMirrorFilter.</param>
        /// 
        /// <returns>Returns a  CreateTrafficMirrorFilterResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorFilter">REST API Reference for CreateTrafficMirrorFilter Operation</seealso>
        public virtual CreateTrafficMirrorFilterResponse EndCreateTrafficMirrorFilter(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTrafficMirrorFilterResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTrafficMirrorFilterRule

        /// <summary>
        /// Creates a Traffic Mirror filter rule.
        /// 
        ///  
        /// <para>
        /// A Traffic Mirror rule defines the Traffic Mirror source traffic to mirror.
        /// </para>
        ///  
        /// <para>
        /// You need the Traffic Mirror filter ID when you create the rule.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTrafficMirrorFilterRule service method.</param>
        /// 
        /// <returns>The response from the CreateTrafficMirrorFilterRule service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorFilterRule">REST API Reference for CreateTrafficMirrorFilterRule Operation</seealso>
        public virtual CreateTrafficMirrorFilterRuleResponse CreateTrafficMirrorFilterRule(CreateTrafficMirrorFilterRuleRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTrafficMirrorFilterRuleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTrafficMirrorFilterRuleResponseUnmarshaller.Instance;

            return Invoke<CreateTrafficMirrorFilterRuleResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTrafficMirrorFilterRule operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTrafficMirrorFilterRule operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTrafficMirrorFilterRule
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorFilterRule">REST API Reference for CreateTrafficMirrorFilterRule Operation</seealso>
        public virtual IAsyncResult BeginCreateTrafficMirrorFilterRule(CreateTrafficMirrorFilterRuleRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTrafficMirrorFilterRuleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTrafficMirrorFilterRuleResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTrafficMirrorFilterRule operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTrafficMirrorFilterRule.</param>
        /// 
        /// <returns>Returns a  CreateTrafficMirrorFilterRuleResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorFilterRule">REST API Reference for CreateTrafficMirrorFilterRule Operation</seealso>
        public virtual CreateTrafficMirrorFilterRuleResponse EndCreateTrafficMirrorFilterRule(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTrafficMirrorFilterRuleResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTrafficMirrorSession

        /// <summary>
        /// Creates a Traffic Mirror session.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// 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.
        /// 
        /// </para>
        ///  
        /// <para>
        /// By default, no traffic is mirrored. Use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorFilter.htm">CreateTrafficMirrorFilter</a>
        /// to create filter rules that specify the traffic to mirror.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTrafficMirrorSession service method.</param>
        /// 
        /// <returns>The response from the CreateTrafficMirrorSession service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorSession">REST API Reference for CreateTrafficMirrorSession Operation</seealso>
        public virtual CreateTrafficMirrorSessionResponse CreateTrafficMirrorSession(CreateTrafficMirrorSessionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTrafficMirrorSessionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTrafficMirrorSessionResponseUnmarshaller.Instance;

            return Invoke<CreateTrafficMirrorSessionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTrafficMirrorSession operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTrafficMirrorSession operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTrafficMirrorSession
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorSession">REST API Reference for CreateTrafficMirrorSession Operation</seealso>
        public virtual IAsyncResult BeginCreateTrafficMirrorSession(CreateTrafficMirrorSessionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTrafficMirrorSessionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTrafficMirrorSessionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTrafficMirrorSession operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTrafficMirrorSession.</param>
        /// 
        /// <returns>Returns a  CreateTrafficMirrorSessionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorSession">REST API Reference for CreateTrafficMirrorSession Operation</seealso>
        public virtual CreateTrafficMirrorSessionResponse EndCreateTrafficMirrorSession(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTrafficMirrorSessionResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTrafficMirrorTarget

        /// <summary>
        /// Creates a target for your Traffic Mirror session.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// A Traffic Mirror target can be a network interface, a Network Load Balancer, or a
        /// Gateway Load Balancer endpoint.
        /// </para>
        ///  
        /// <para>
        /// To use the target in a Traffic Mirror session, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTrafficMirrorSession.htm">CreateTrafficMirrorSession</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTrafficMirrorTarget service method.</param>
        /// 
        /// <returns>The response from the CreateTrafficMirrorTarget service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorTarget">REST API Reference for CreateTrafficMirrorTarget Operation</seealso>
        public virtual CreateTrafficMirrorTargetResponse CreateTrafficMirrorTarget(CreateTrafficMirrorTargetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTrafficMirrorTargetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTrafficMirrorTargetResponseUnmarshaller.Instance;

            return Invoke<CreateTrafficMirrorTargetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTrafficMirrorTarget operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTrafficMirrorTarget operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTrafficMirrorTarget
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorTarget">REST API Reference for CreateTrafficMirrorTarget Operation</seealso>
        public virtual IAsyncResult BeginCreateTrafficMirrorTarget(CreateTrafficMirrorTargetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTrafficMirrorTargetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTrafficMirrorTargetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTrafficMirrorTarget operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTrafficMirrorTarget.</param>
        /// 
        /// <returns>Returns a  CreateTrafficMirrorTargetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTrafficMirrorTarget">REST API Reference for CreateTrafficMirrorTarget Operation</seealso>
        public virtual CreateTrafficMirrorTargetResponse EndCreateTrafficMirrorTarget(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTrafficMirrorTargetResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGateway

        /// <summary>
        /// Creates a transit gateway.
        /// 
        ///  
        /// <para>
        /// You can use a transit gateway to interconnect your virtual private clouds (VPC) and
        /// on-premises networks. After the transit gateway enters the <code>available</code>
        /// state, you can attach your VPCs and VPN connections to the transit gateway.
        /// </para>
        ///  
        /// <para>
        /// To attach your VPCs, use <a>CreateTransitGatewayVpcAttachment</a>.
        /// </para>
        ///  
        /// <para>
        /// To attach a VPN connection, use <a>CreateCustomerGateway</a> to create a customer
        /// gateway and specify the ID of the customer gateway and the ID of the transit gateway
        /// in a call to <a>CreateVpnConnection</a>.
        /// </para>
        ///  
        /// <para>
        /// When you create a transit gateway, we create a default transit gateway route table
        /// and use it as the default association route table and the default propagation route
        /// table. You can use <a>CreateTransitGatewayRouteTable</a> to create additional transit
        /// gateway route tables. If you disable automatic route propagation, we do not create
        /// a default transit gateway route table. You can use <a>EnableTransitGatewayRouteTablePropagation</a>
        /// to propagate routes from a resource attachment to a transit gateway route table. If
        /// you disable automatic associations, you can use <a>AssociateTransitGatewayRouteTable</a>
        /// to associate a resource attachment with a transit gateway route table.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGateway service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGateway">REST API Reference for CreateTransitGateway Operation</seealso>
        public virtual CreateTransitGatewayResponse CreateTransitGateway(CreateTransitGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGateway">REST API Reference for CreateTransitGateway Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGateway(CreateTransitGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGateway.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGateway">REST API Reference for CreateTransitGateway Operation</seealso>
        public virtual CreateTransitGatewayResponse EndCreateTransitGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayConnect

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// A Connect attachment uses an existing VPC or Amazon Web Services Direct Connect attachment
        /// as the underlying transport mechanism.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayConnect service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayConnect service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayConnect">REST API Reference for CreateTransitGatewayConnect Operation</seealso>
        public virtual CreateTransitGatewayConnectResponse CreateTransitGatewayConnect(CreateTransitGatewayConnectRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayConnectRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayConnectResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayConnectResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayConnect operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayConnect operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayConnect
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayConnect">REST API Reference for CreateTransitGatewayConnect Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayConnect(CreateTransitGatewayConnectRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayConnectRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayConnectResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayConnect operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayConnect.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayConnectResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayConnect">REST API Reference for CreateTransitGatewayConnect Operation</seealso>
        public virtual CreateTransitGatewayConnectResponse EndCreateTransitGatewayConnect(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayConnectResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayConnectPeer

        /// <summary>
        /// Creates a Connect peer for a specified transit gateway Connect attachment between
        /// a transit gateway and an appliance.
        /// 
        ///  
        /// <para>
        /// The peer address and transit gateway address must be the same IP address family (IPv4
        /// or IPv6).
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-connect.html#tgw-connect-peer">Connect
        /// peers</a> in the <i>Transit Gateways Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayConnectPeer service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayConnectPeer service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayConnectPeer">REST API Reference for CreateTransitGatewayConnectPeer Operation</seealso>
        public virtual CreateTransitGatewayConnectPeerResponse CreateTransitGatewayConnectPeer(CreateTransitGatewayConnectPeerRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayConnectPeerRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayConnectPeerResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayConnectPeerResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayConnectPeer operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayConnectPeer operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayConnectPeer
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayConnectPeer">REST API Reference for CreateTransitGatewayConnectPeer Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayConnectPeer(CreateTransitGatewayConnectPeerRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayConnectPeerRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayConnectPeerResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayConnectPeer operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayConnectPeer.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayConnectPeerResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayConnectPeer">REST API Reference for CreateTransitGatewayConnectPeer Operation</seealso>
        public virtual CreateTransitGatewayConnectPeerResponse EndCreateTransitGatewayConnectPeer(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayConnectPeerResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayMulticastDomain

        /// <summary>
        /// Creates a multicast domain using the specified transit gateway.
        /// 
        ///  
        /// <para>
        /// The transit gateway must be in the available state before you create a domain. Use
        /// <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeTransitGateways.html">DescribeTransitGateways</a>
        /// to see the state of transit gateway.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayMulticastDomain service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayMulticastDomain service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayMulticastDomain">REST API Reference for CreateTransitGatewayMulticastDomain Operation</seealso>
        public virtual CreateTransitGatewayMulticastDomainResponse CreateTransitGatewayMulticastDomain(CreateTransitGatewayMulticastDomainRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayMulticastDomainRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayMulticastDomainResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayMulticastDomainResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayMulticastDomain operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayMulticastDomain operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayMulticastDomain
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayMulticastDomain">REST API Reference for CreateTransitGatewayMulticastDomain Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayMulticastDomain(CreateTransitGatewayMulticastDomainRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayMulticastDomainRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayMulticastDomainResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayMulticastDomain operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayMulticastDomain.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayMulticastDomainResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayMulticastDomain">REST API Reference for CreateTransitGatewayMulticastDomain Operation</seealso>
        public virtual CreateTransitGatewayMulticastDomainResponse EndCreateTransitGatewayMulticastDomain(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayMulticastDomainResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayPeeringAttachment

        /// <summary>
        /// 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.
        /// 
        ///  
        /// <para>
        /// After you create the peering attachment, the owner of the accepter transit gateway
        /// must accept the attachment request.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayPeeringAttachment service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayPeeringAttachment service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPeeringAttachment">REST API Reference for CreateTransitGatewayPeeringAttachment Operation</seealso>
        public virtual CreateTransitGatewayPeeringAttachmentResponse CreateTransitGatewayPeeringAttachment(CreateTransitGatewayPeeringAttachmentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayPeeringAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayPeeringAttachmentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayPeeringAttachment operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayPeeringAttachment operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayPeeringAttachment
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPeeringAttachment">REST API Reference for CreateTransitGatewayPeeringAttachment Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayPeeringAttachment(CreateTransitGatewayPeeringAttachmentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayPeeringAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayPeeringAttachment operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayPeeringAttachment.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayPeeringAttachmentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPeeringAttachment">REST API Reference for CreateTransitGatewayPeeringAttachment Operation</seealso>
        public virtual CreateTransitGatewayPeeringAttachmentResponse EndCreateTransitGatewayPeeringAttachment(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayPeeringAttachmentResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayPolicyTable

        /// <summary>
        /// Creates a transit gateway policy table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayPolicyTable service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayPolicyTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPolicyTable">REST API Reference for CreateTransitGatewayPolicyTable Operation</seealso>
        public virtual CreateTransitGatewayPolicyTableResponse CreateTransitGatewayPolicyTable(CreateTransitGatewayPolicyTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayPolicyTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayPolicyTableResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayPolicyTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayPolicyTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayPolicyTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayPolicyTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPolicyTable">REST API Reference for CreateTransitGatewayPolicyTable Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayPolicyTable(CreateTransitGatewayPolicyTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayPolicyTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayPolicyTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayPolicyTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayPolicyTable.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayPolicyTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPolicyTable">REST API Reference for CreateTransitGatewayPolicyTable Operation</seealso>
        public virtual CreateTransitGatewayPolicyTableResponse EndCreateTransitGatewayPolicyTable(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayPolicyTableResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayPrefixListReference

        /// <summary>
        /// Creates a reference (route) to a prefix list in a specified transit gateway route
        /// table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayPrefixListReference service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayPrefixListReference service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPrefixListReference">REST API Reference for CreateTransitGatewayPrefixListReference Operation</seealso>
        public virtual CreateTransitGatewayPrefixListReferenceResponse CreateTransitGatewayPrefixListReference(CreateTransitGatewayPrefixListReferenceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayPrefixListReferenceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayPrefixListReferenceResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayPrefixListReferenceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayPrefixListReference operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayPrefixListReference operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayPrefixListReference
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPrefixListReference">REST API Reference for CreateTransitGatewayPrefixListReference Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayPrefixListReference(CreateTransitGatewayPrefixListReferenceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayPrefixListReferenceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayPrefixListReferenceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayPrefixListReference operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayPrefixListReference.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayPrefixListReferenceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayPrefixListReference">REST API Reference for CreateTransitGatewayPrefixListReference Operation</seealso>
        public virtual CreateTransitGatewayPrefixListReferenceResponse EndCreateTransitGatewayPrefixListReference(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayPrefixListReferenceResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayRoute

        /// <summary>
        /// Creates a static route for the specified transit gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayRoute service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRoute">REST API Reference for CreateTransitGatewayRoute Operation</seealso>
        public virtual CreateTransitGatewayRouteResponse CreateTransitGatewayRoute(CreateTransitGatewayRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayRouteResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRoute">REST API Reference for CreateTransitGatewayRoute Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayRoute(CreateTransitGatewayRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayRoute.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRoute">REST API Reference for CreateTransitGatewayRoute Operation</seealso>
        public virtual CreateTransitGatewayRouteResponse EndCreateTransitGatewayRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayRouteTable

        /// <summary>
        /// Creates a route table for the specified transit gateway.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayRouteTable service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRouteTable">REST API Reference for CreateTransitGatewayRouteTable Operation</seealso>
        public virtual CreateTransitGatewayRouteTableResponse CreateTransitGatewayRouteTable(CreateTransitGatewayRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayRouteTableResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRouteTable">REST API Reference for CreateTransitGatewayRouteTable Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayRouteTable(CreateTransitGatewayRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayRouteTable.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRouteTable">REST API Reference for CreateTransitGatewayRouteTable Operation</seealso>
        public virtual CreateTransitGatewayRouteTableResponse EndCreateTransitGatewayRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayRouteTableAnnouncement

        /// <summary>
        /// Advertises a new transit gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayRouteTableAnnouncement service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayRouteTableAnnouncement service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRouteTableAnnouncement">REST API Reference for CreateTransitGatewayRouteTableAnnouncement Operation</seealso>
        public virtual CreateTransitGatewayRouteTableAnnouncementResponse CreateTransitGatewayRouteTableAnnouncement(CreateTransitGatewayRouteTableAnnouncementRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayRouteTableAnnouncementRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayRouteTableAnnouncementResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayRouteTableAnnouncementResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayRouteTableAnnouncement operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayRouteTableAnnouncement operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayRouteTableAnnouncement
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRouteTableAnnouncement">REST API Reference for CreateTransitGatewayRouteTableAnnouncement Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayRouteTableAnnouncement(CreateTransitGatewayRouteTableAnnouncementRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayRouteTableAnnouncementRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayRouteTableAnnouncementResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayRouteTableAnnouncement operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayRouteTableAnnouncement.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayRouteTableAnnouncementResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayRouteTableAnnouncement">REST API Reference for CreateTransitGatewayRouteTableAnnouncement Operation</seealso>
        public virtual CreateTransitGatewayRouteTableAnnouncementResponse EndCreateTransitGatewayRouteTableAnnouncement(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayRouteTableAnnouncementResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateTransitGatewayVpcAttachment

        /// <summary>
        /// Attaches the specified VPC to the specified transit gateway.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// To send VPC traffic to an attached transit gateway, add a route to the VPC route table
        /// using <a>CreateRoute</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayVpcAttachment service method.</param>
        /// 
        /// <returns>The response from the CreateTransitGatewayVpcAttachment service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayVpcAttachment">REST API Reference for CreateTransitGatewayVpcAttachment Operation</seealso>
        public virtual CreateTransitGatewayVpcAttachmentResponse CreateTransitGatewayVpcAttachment(CreateTransitGatewayVpcAttachmentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return Invoke<CreateTransitGatewayVpcAttachmentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateTransitGatewayVpcAttachment operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTransitGatewayVpcAttachment
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayVpcAttachment">REST API Reference for CreateTransitGatewayVpcAttachment Operation</seealso>
        public virtual IAsyncResult BeginCreateTransitGatewayVpcAttachment(CreateTransitGatewayVpcAttachmentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateTransitGatewayVpcAttachment.</param>
        /// 
        /// <returns>Returns a  CreateTransitGatewayVpcAttachmentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateTransitGatewayVpcAttachment">REST API Reference for CreateTransitGatewayVpcAttachment Operation</seealso>
        public virtual CreateTransitGatewayVpcAttachmentResponse EndCreateTransitGatewayVpcAttachment(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateTransitGatewayVpcAttachmentResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVerifiedAccessEndpoint

        /// <summary>
        /// An Amazon Web Services Verified Access endpoint is where you define your application
        /// along with an optional endpoint-level access policy.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVerifiedAccessEndpoint service method.</param>
        /// 
        /// <returns>The response from the CreateVerifiedAccessEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessEndpoint">REST API Reference for CreateVerifiedAccessEndpoint Operation</seealso>
        public virtual CreateVerifiedAccessEndpointResponse CreateVerifiedAccessEndpoint(CreateVerifiedAccessEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVerifiedAccessEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVerifiedAccessEndpointResponseUnmarshaller.Instance;

            return Invoke<CreateVerifiedAccessEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVerifiedAccessEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVerifiedAccessEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVerifiedAccessEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessEndpoint">REST API Reference for CreateVerifiedAccessEndpoint Operation</seealso>
        public virtual IAsyncResult BeginCreateVerifiedAccessEndpoint(CreateVerifiedAccessEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVerifiedAccessEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVerifiedAccessEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVerifiedAccessEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVerifiedAccessEndpoint.</param>
        /// 
        /// <returns>Returns a  CreateVerifiedAccessEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessEndpoint">REST API Reference for CreateVerifiedAccessEndpoint Operation</seealso>
        public virtual CreateVerifiedAccessEndpointResponse EndCreateVerifiedAccessEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVerifiedAccessEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVerifiedAccessGroup

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVerifiedAccessGroup service method.</param>
        /// 
        /// <returns>The response from the CreateVerifiedAccessGroup service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessGroup">REST API Reference for CreateVerifiedAccessGroup Operation</seealso>
        public virtual CreateVerifiedAccessGroupResponse CreateVerifiedAccessGroup(CreateVerifiedAccessGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVerifiedAccessGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVerifiedAccessGroupResponseUnmarshaller.Instance;

            return Invoke<CreateVerifiedAccessGroupResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVerifiedAccessGroup operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVerifiedAccessGroup operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVerifiedAccessGroup
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessGroup">REST API Reference for CreateVerifiedAccessGroup Operation</seealso>
        public virtual IAsyncResult BeginCreateVerifiedAccessGroup(CreateVerifiedAccessGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVerifiedAccessGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVerifiedAccessGroupResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVerifiedAccessGroup operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVerifiedAccessGroup.</param>
        /// 
        /// <returns>Returns a  CreateVerifiedAccessGroupResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessGroup">REST API Reference for CreateVerifiedAccessGroup Operation</seealso>
        public virtual CreateVerifiedAccessGroupResponse EndCreateVerifiedAccessGroup(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVerifiedAccessGroupResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVerifiedAccessInstance

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVerifiedAccessInstance service method.</param>
        /// 
        /// <returns>The response from the CreateVerifiedAccessInstance service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessInstance">REST API Reference for CreateVerifiedAccessInstance Operation</seealso>
        public virtual CreateVerifiedAccessInstanceResponse CreateVerifiedAccessInstance(CreateVerifiedAccessInstanceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVerifiedAccessInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVerifiedAccessInstanceResponseUnmarshaller.Instance;

            return Invoke<CreateVerifiedAccessInstanceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVerifiedAccessInstance operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVerifiedAccessInstance operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVerifiedAccessInstance
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessInstance">REST API Reference for CreateVerifiedAccessInstance Operation</seealso>
        public virtual IAsyncResult BeginCreateVerifiedAccessInstance(CreateVerifiedAccessInstanceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVerifiedAccessInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVerifiedAccessInstanceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVerifiedAccessInstance operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVerifiedAccessInstance.</param>
        /// 
        /// <returns>Returns a  CreateVerifiedAccessInstanceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessInstance">REST API Reference for CreateVerifiedAccessInstance Operation</seealso>
        public virtual CreateVerifiedAccessInstanceResponse EndCreateVerifiedAccessInstance(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVerifiedAccessInstanceResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVerifiedAccessTrustProvider

        /// <summary>
        /// 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.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVerifiedAccessTrustProvider service method.</param>
        /// 
        /// <returns>The response from the CreateVerifiedAccessTrustProvider service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessTrustProvider">REST API Reference for CreateVerifiedAccessTrustProvider Operation</seealso>
        public virtual CreateVerifiedAccessTrustProviderResponse CreateVerifiedAccessTrustProvider(CreateVerifiedAccessTrustProviderRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return Invoke<CreateVerifiedAccessTrustProviderResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVerifiedAccessTrustProvider operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVerifiedAccessTrustProvider
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessTrustProvider">REST API Reference for CreateVerifiedAccessTrustProvider Operation</seealso>
        public virtual IAsyncResult BeginCreateVerifiedAccessTrustProvider(CreateVerifiedAccessTrustProviderRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVerifiedAccessTrustProvider.</param>
        /// 
        /// <returns>Returns a  CreateVerifiedAccessTrustProviderResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVerifiedAccessTrustProvider">REST API Reference for CreateVerifiedAccessTrustProvider Operation</seealso>
        public virtual CreateVerifiedAccessTrustProviderResponse EndCreateVerifiedAccessTrustProvider(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVerifiedAccessTrustProviderResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVolume

        /// <summary>
        /// Creates an EBS volume that can be attached to an instance in the same Availability
        /// Zone.
        /// 
        ///  
        /// <para>
        /// 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.
        /// </para>
        ///  
        /// <para>
        /// You can create encrypted volumes. Encrypted volumes must be attached to instances
        /// that support Amazon EBS encryption. Volumes that are created from encrypted snapshots
        /// are also automatically encrypted. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon
        /// EBS encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// You can tag your volumes during creation. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
        /// your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-creating-volume.html">Create
        /// an Amazon EBS volume</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVolume service method.</param>
        /// 
        /// <returns>The response from the CreateVolume service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVolume">REST API Reference for CreateVolume Operation</seealso>
        public virtual CreateVolumeResponse CreateVolume(CreateVolumeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVolumeResponseUnmarshaller.Instance;

            return Invoke<CreateVolumeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVolume operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVolume operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVolume
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVolume">REST API Reference for CreateVolume Operation</seealso>
        public virtual IAsyncResult BeginCreateVolume(CreateVolumeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVolumeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVolume operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVolume.</param>
        /// 
        /// <returns>Returns a  CreateVolumeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVolume">REST API Reference for CreateVolume Operation</seealso>
        public virtual CreateVolumeResponse EndCreateVolume(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVolumeResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVpc

        /// <summary>
        /// Creates a VPC with the specified CIDR blocks. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-ip-addressing.html">IP
        /// addressing for your VPCs and subnets</a> in the <i>Amazon VPC User Guide</i>.
        /// 
        ///  
        /// <para>
        /// 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 (<a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">BYOIP</a>).
        /// </para>
        ///  
        /// <para>
        /// By default, each instance that you launch in the VPC has the default DHCP options,
        /// which include only a default DNS server that we provide (AmazonProvidedDNS). For more
        /// information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP
        /// option sets</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// 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 <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html">Dedicated
        /// Instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVpc service method.</param>
        /// 
        /// <returns>The response from the CreateVpc service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpc">REST API Reference for CreateVpc Operation</seealso>
        public virtual CreateVpcResponse CreateVpc(CreateVpcRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcResponseUnmarshaller.Instance;

            return Invoke<CreateVpcResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVpc operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVpc operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVpc
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpc">REST API Reference for CreateVpc Operation</seealso>
        public virtual IAsyncResult BeginCreateVpc(CreateVpcRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVpc operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVpc.</param>
        /// 
        /// <returns>Returns a  CreateVpcResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpc">REST API Reference for CreateVpc Operation</seealso>
        public virtual CreateVpcResponse EndCreateVpc(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVpcResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVpcEndpoint

        /// <summary>
        /// Creates a VPC endpoint. A VPC endpoint provides a private connection between the specified
        /// VPC and the specified endpoint service. You can use an endpoint service provided by
        /// Amazon Web Services, an Amazon Web Services Marketplace Partner, or another Amazon
        /// Web Services account. For more information, see the <a href="https://docs.aws.amazon.com/vpc/latest/privatelink/">Amazon
        /// Web Services PrivateLink User Guide</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVpcEndpoint service method.</param>
        /// 
        /// <returns>The response from the CreateVpcEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpoint">REST API Reference for CreateVpcEndpoint Operation</seealso>
        public virtual CreateVpcEndpointResponse CreateVpcEndpoint(CreateVpcEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcEndpointResponseUnmarshaller.Instance;

            return Invoke<CreateVpcEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVpcEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVpcEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVpcEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpoint">REST API Reference for CreateVpcEndpoint Operation</seealso>
        public virtual IAsyncResult BeginCreateVpcEndpoint(CreateVpcEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVpcEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVpcEndpoint.</param>
        /// 
        /// <returns>Returns a  CreateVpcEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpoint">REST API Reference for CreateVpcEndpoint Operation</seealso>
        public virtual CreateVpcEndpointResponse EndCreateVpcEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVpcEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVpcEndpointConnectionNotification

        /// <summary>
        /// Creates a connection notification for a specified VPC endpoint or VPC endpoint service.
        /// A connection notification notifies you of specific endpoint events. You must create
        /// an SNS topic to receive notifications. For more information, see <a href="https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html">Create
        /// a Topic</a> in the <i>Amazon Simple Notification Service Developer Guide</i>.
        /// 
        ///  
        /// <para>
        /// You can create a connection notification for interface endpoints only.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVpcEndpointConnectionNotification service method.</param>
        /// 
        /// <returns>The response from the CreateVpcEndpointConnectionNotification service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpointConnectionNotification">REST API Reference for CreateVpcEndpointConnectionNotification Operation</seealso>
        public virtual CreateVpcEndpointConnectionNotificationResponse CreateVpcEndpointConnectionNotification(CreateVpcEndpointConnectionNotificationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcEndpointConnectionNotificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcEndpointConnectionNotificationResponseUnmarshaller.Instance;

            return Invoke<CreateVpcEndpointConnectionNotificationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVpcEndpointConnectionNotification operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVpcEndpointConnectionNotification operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVpcEndpointConnectionNotification
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpointConnectionNotification">REST API Reference for CreateVpcEndpointConnectionNotification Operation</seealso>
        public virtual IAsyncResult BeginCreateVpcEndpointConnectionNotification(CreateVpcEndpointConnectionNotificationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcEndpointConnectionNotificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcEndpointConnectionNotificationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVpcEndpointConnectionNotification operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVpcEndpointConnectionNotification.</param>
        /// 
        /// <returns>Returns a  CreateVpcEndpointConnectionNotificationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpointConnectionNotification">REST API Reference for CreateVpcEndpointConnectionNotification Operation</seealso>
        public virtual CreateVpcEndpointConnectionNotificationResponse EndCreateVpcEndpointConnectionNotification(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVpcEndpointConnectionNotificationResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVpcEndpointServiceConfiguration

        /// <summary>
        /// Creates a VPC endpoint service to which service consumers (Amazon Web Services accounts,
        /// users, and IAM roles) can connect.
        /// 
        ///  
        /// <para>
        /// Before you create an endpoint service, you must create one of the following for your
        /// service:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        /// A <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/network/">Network
        /// Load Balancer</a>. Service consumers connect to your service using an interface endpoint.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// A <a href="https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/">Gateway
        /// Load Balancer</a>. Service consumers connect to your service using a Gateway Load
        /// Balancer endpoint.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// If you set the private DNS name, you must prove that you own the private DNS domain
        /// name.
        /// </para>
        ///  
        /// <para>
        /// For more information, see the <a href="https://docs.aws.amazon.com/vpc/latest/privatelink/">Amazon
        /// Web Services PrivateLink Guide</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVpcEndpointServiceConfiguration service method.</param>
        /// 
        /// <returns>The response from the CreateVpcEndpointServiceConfiguration service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpointServiceConfiguration">REST API Reference for CreateVpcEndpointServiceConfiguration Operation</seealso>
        public virtual CreateVpcEndpointServiceConfigurationResponse CreateVpcEndpointServiceConfiguration(CreateVpcEndpointServiceConfigurationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcEndpointServiceConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcEndpointServiceConfigurationResponseUnmarshaller.Instance;

            return Invoke<CreateVpcEndpointServiceConfigurationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVpcEndpointServiceConfiguration operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVpcEndpointServiceConfiguration operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVpcEndpointServiceConfiguration
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpointServiceConfiguration">REST API Reference for CreateVpcEndpointServiceConfiguration Operation</seealso>
        public virtual IAsyncResult BeginCreateVpcEndpointServiceConfiguration(CreateVpcEndpointServiceConfigurationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcEndpointServiceConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcEndpointServiceConfigurationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVpcEndpointServiceConfiguration operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVpcEndpointServiceConfiguration.</param>
        /// 
        /// <returns>Returns a  CreateVpcEndpointServiceConfigurationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcEndpointServiceConfiguration">REST API Reference for CreateVpcEndpointServiceConfiguration Operation</seealso>
        public virtual CreateVpcEndpointServiceConfigurationResponse EndCreateVpcEndpointServiceConfiguration(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVpcEndpointServiceConfigurationResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVpcPeeringConnection

        /// <summary>
        /// Requests a VPC peering connection between two VPCs: a requester VPC that you own and
        /// an accepter VPC with which to create the connection. The accepter VPC can belong to
        /// another Amazon Web Services account and can be in a different Region to the requester
        /// VPC. The requester VPC and accepter VPC cannot have overlapping CIDR blocks.
        /// 
        ///  <note> 
        /// <para>
        /// Limitations and rules apply to a VPC peering connection. For more information, see
        /// the <a href="https://docs.aws.amazon.com/vpc/latest/peering/vpc-peering-basics.html#vpc-peering-limitations">limitations</a>
        /// section in the <i>VPC Peering Guide</i>.
        /// </para>
        ///  </note> 
        /// <para>
        /// The owner of the accepter VPC must accept the peering request to activate the peering
        /// connection. The VPC peering connection request expires after 7 days, after which it
        /// cannot be accepted or rejected.
        /// </para>
        ///  
        /// <para>
        /// If you create a VPC peering connection request between VPCs with overlapping CIDR
        /// blocks, the VPC peering connection has a status of <code>failed</code>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVpcPeeringConnection service method.</param>
        /// 
        /// <returns>The response from the CreateVpcPeeringConnection service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcPeeringConnection">REST API Reference for CreateVpcPeeringConnection Operation</seealso>
        public virtual CreateVpcPeeringConnectionResponse CreateVpcPeeringConnection(CreateVpcPeeringConnectionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcPeeringConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcPeeringConnectionResponseUnmarshaller.Instance;

            return Invoke<CreateVpcPeeringConnectionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVpcPeeringConnection operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVpcPeeringConnection operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVpcPeeringConnection
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcPeeringConnection">REST API Reference for CreateVpcPeeringConnection Operation</seealso>
        public virtual IAsyncResult BeginCreateVpcPeeringConnection(CreateVpcPeeringConnectionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpcPeeringConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpcPeeringConnectionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVpcPeeringConnection operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVpcPeeringConnection.</param>
        /// 
        /// <returns>Returns a  CreateVpcPeeringConnectionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpcPeeringConnection">REST API Reference for CreateVpcPeeringConnection Operation</seealso>
        public virtual CreateVpcPeeringConnectionResponse EndCreateVpcPeeringConnection(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVpcPeeringConnectionResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVpnConnection

        /// <summary>
        /// Creates a VPN connection between an existing virtual private gateway or transit gateway
        /// and a customer gateway. The supported connection type is <code>ipsec.1</code>.
        /// 
        ///  
        /// <para>
        /// The response includes information that you need to give to your network administrator
        /// to configure your customer gateway.
        /// </para>
        ///  <important> 
        /// <para>
        /// We strongly recommend that you use HTTPS when calling this operation because the response
        /// contains sensitive cryptographic information for configuring your customer gateway
        /// device.
        /// </para>
        ///  </important> 
        /// <para>
        /// If you decide to shut down your VPN connection for any reason and later create a new
        /// VPN connection, you must reconfigure your customer gateway with the new information
        /// returned from this call.
        /// </para>
        ///  
        /// <para>
        /// This is an idempotent operation. If you perform the operation more than once, Amazon
        /// EC2 doesn't return an error.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVpnConnection service method.</param>
        /// 
        /// <returns>The response from the CreateVpnConnection service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnection">REST API Reference for CreateVpnConnection Operation</seealso>
        public virtual CreateVpnConnectionResponse CreateVpnConnection(CreateVpnConnectionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpnConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpnConnectionResponseUnmarshaller.Instance;

            return Invoke<CreateVpnConnectionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVpnConnection operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVpnConnection operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVpnConnection
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnection">REST API Reference for CreateVpnConnection Operation</seealso>
        public virtual IAsyncResult BeginCreateVpnConnection(CreateVpnConnectionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpnConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpnConnectionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVpnConnection operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVpnConnection.</param>
        /// 
        /// <returns>Returns a  CreateVpnConnectionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnection">REST API Reference for CreateVpnConnection Operation</seealso>
        public virtual CreateVpnConnectionResponse EndCreateVpnConnection(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVpnConnectionResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVpnConnectionRoute

        /// <summary>
        /// Creates a static route associated with a VPN connection between an existing virtual
        /// private gateway and a VPN customer gateway. The static route allows traffic to be
        /// routed from the virtual private gateway to the VPN customer gateway.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVpnConnectionRoute service method.</param>
        /// 
        /// <returns>The response from the CreateVpnConnectionRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnectionRoute">REST API Reference for CreateVpnConnectionRoute Operation</seealso>
        public virtual CreateVpnConnectionRouteResponse CreateVpnConnectionRoute(CreateVpnConnectionRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpnConnectionRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpnConnectionRouteResponseUnmarshaller.Instance;

            return Invoke<CreateVpnConnectionRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVpnConnectionRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVpnConnectionRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVpnConnectionRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnectionRoute">REST API Reference for CreateVpnConnectionRoute Operation</seealso>
        public virtual IAsyncResult BeginCreateVpnConnectionRoute(CreateVpnConnectionRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpnConnectionRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpnConnectionRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVpnConnectionRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVpnConnectionRoute.</param>
        /// 
        /// <returns>Returns a  CreateVpnConnectionRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnConnectionRoute">REST API Reference for CreateVpnConnectionRoute Operation</seealso>
        public virtual CreateVpnConnectionRouteResponse EndCreateVpnConnectionRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVpnConnectionRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  CreateVpnGateway

        /// <summary>
        /// Creates a virtual private gateway. A virtual private gateway is the endpoint on the
        /// VPC side of your VPN connection. You can create a virtual private gateway before creating
        /// the VPC itself.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the CreateVpnGateway service method.</param>
        /// 
        /// <returns>The response from the CreateVpnGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnGateway">REST API Reference for CreateVpnGateway Operation</seealso>
        public virtual CreateVpnGatewayResponse CreateVpnGateway(CreateVpnGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpnGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpnGatewayResponseUnmarshaller.Instance;

            return Invoke<CreateVpnGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the CreateVpnGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the CreateVpnGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateVpnGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnGateway">REST API Reference for CreateVpnGateway Operation</seealso>
        public virtual IAsyncResult BeginCreateVpnGateway(CreateVpnGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = CreateVpnGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = CreateVpnGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  CreateVpnGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginCreateVpnGateway.</param>
        /// 
        /// <returns>Returns a  CreateVpnGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/CreateVpnGateway">REST API Reference for CreateVpnGateway Operation</seealso>
        public virtual CreateVpnGatewayResponse EndCreateVpnGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<CreateVpnGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteCarrierGateway

        /// <summary>
        /// Deletes a carrier gateway.
        /// 
        ///  <important> 
        /// <para>
        /// If you do not delete the route that contains the carrier gateway as the Target, the
        /// route is a blackhole route. For information about how to delete a route, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteRoute.html">DeleteRoute</a>.
        /// </para>
        ///  </important>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteCarrierGateway service method.</param>
        /// 
        /// <returns>The response from the DeleteCarrierGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCarrierGateway">REST API Reference for DeleteCarrierGateway Operation</seealso>
        public virtual DeleteCarrierGatewayResponse DeleteCarrierGateway(DeleteCarrierGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteCarrierGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteCarrierGatewayResponseUnmarshaller.Instance;

            return Invoke<DeleteCarrierGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteCarrierGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteCarrierGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteCarrierGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCarrierGateway">REST API Reference for DeleteCarrierGateway Operation</seealso>
        public virtual IAsyncResult BeginDeleteCarrierGateway(DeleteCarrierGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteCarrierGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteCarrierGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteCarrierGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteCarrierGateway.</param>
        /// 
        /// <returns>Returns a  DeleteCarrierGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCarrierGateway">REST API Reference for DeleteCarrierGateway Operation</seealso>
        public virtual DeleteCarrierGatewayResponse EndDeleteCarrierGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteCarrierGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteClientVpnEndpoint

        /// <summary>
        /// Deletes the specified Client VPN endpoint. You must disassociate all target networks
        /// before you can delete a Client VPN endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteClientVpnEndpoint service method.</param>
        /// 
        /// <returns>The response from the DeleteClientVpnEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteClientVpnEndpoint">REST API Reference for DeleteClientVpnEndpoint Operation</seealso>
        public virtual DeleteClientVpnEndpointResponse DeleteClientVpnEndpoint(DeleteClientVpnEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteClientVpnEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteClientVpnEndpointResponseUnmarshaller.Instance;

            return Invoke<DeleteClientVpnEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteClientVpnEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteClientVpnEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteClientVpnEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteClientVpnEndpoint">REST API Reference for DeleteClientVpnEndpoint Operation</seealso>
        public virtual IAsyncResult BeginDeleteClientVpnEndpoint(DeleteClientVpnEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteClientVpnEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteClientVpnEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteClientVpnEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteClientVpnEndpoint.</param>
        /// 
        /// <returns>Returns a  DeleteClientVpnEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteClientVpnEndpoint">REST API Reference for DeleteClientVpnEndpoint Operation</seealso>
        public virtual DeleteClientVpnEndpointResponse EndDeleteClientVpnEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteClientVpnEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteClientVpnRoute

        /// <summary>
        /// Deletes a route from a Client VPN endpoint. You can only delete routes that you manually
        /// added using the <b>CreateClientVpnRoute</b> action. You cannot delete routes that
        /// were automatically added when associating a subnet. To remove routes that have been
        /// automatically added, disassociate the target subnet from the Client VPN endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteClientVpnRoute service method.</param>
        /// 
        /// <returns>The response from the DeleteClientVpnRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteClientVpnRoute">REST API Reference for DeleteClientVpnRoute Operation</seealso>
        public virtual DeleteClientVpnRouteResponse DeleteClientVpnRoute(DeleteClientVpnRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteClientVpnRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteClientVpnRouteResponseUnmarshaller.Instance;

            return Invoke<DeleteClientVpnRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteClientVpnRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteClientVpnRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteClientVpnRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteClientVpnRoute">REST API Reference for DeleteClientVpnRoute Operation</seealso>
        public virtual IAsyncResult BeginDeleteClientVpnRoute(DeleteClientVpnRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteClientVpnRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteClientVpnRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteClientVpnRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteClientVpnRoute.</param>
        /// 
        /// <returns>Returns a  DeleteClientVpnRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteClientVpnRoute">REST API Reference for DeleteClientVpnRoute Operation</seealso>
        public virtual DeleteClientVpnRouteResponse EndDeleteClientVpnRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteClientVpnRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteCoipCidr

        /// <summary>
        /// Deletes a range of customer-owned IP addresses.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteCoipCidr service method.</param>
        /// 
        /// <returns>The response from the DeleteCoipCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCoipCidr">REST API Reference for DeleteCoipCidr Operation</seealso>
        public virtual DeleteCoipCidrResponse DeleteCoipCidr(DeleteCoipCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteCoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteCoipCidrResponseUnmarshaller.Instance;

            return Invoke<DeleteCoipCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteCoipCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteCoipCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteCoipCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCoipCidr">REST API Reference for DeleteCoipCidr Operation</seealso>
        public virtual IAsyncResult BeginDeleteCoipCidr(DeleteCoipCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteCoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteCoipCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteCoipCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteCoipCidr.</param>
        /// 
        /// <returns>Returns a  DeleteCoipCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCoipCidr">REST API Reference for DeleteCoipCidr Operation</seealso>
        public virtual DeleteCoipCidrResponse EndDeleteCoipCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteCoipCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteCoipPool

        /// <summary>
        /// Deletes a pool of customer-owned IP (CoIP) addresses.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteCoipPool service method.</param>
        /// 
        /// <returns>The response from the DeleteCoipPool service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCoipPool">REST API Reference for DeleteCoipPool Operation</seealso>
        public virtual DeleteCoipPoolResponse DeleteCoipPool(DeleteCoipPoolRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteCoipPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteCoipPoolResponseUnmarshaller.Instance;

            return Invoke<DeleteCoipPoolResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteCoipPool operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteCoipPool operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteCoipPool
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCoipPool">REST API Reference for DeleteCoipPool Operation</seealso>
        public virtual IAsyncResult BeginDeleteCoipPool(DeleteCoipPoolRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteCoipPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteCoipPoolResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteCoipPool operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteCoipPool.</param>
        /// 
        /// <returns>Returns a  DeleteCoipPoolResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCoipPool">REST API Reference for DeleteCoipPool Operation</seealso>
        public virtual DeleteCoipPoolResponse EndDeleteCoipPool(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteCoipPoolResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteCustomerGateway

        /// <summary>
        /// Deletes the specified customer gateway. You must delete the VPN connection before
        /// you can delete the customer gateway.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteCustomerGateway service method.</param>
        /// 
        /// <returns>The response from the DeleteCustomerGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCustomerGateway">REST API Reference for DeleteCustomerGateway Operation</seealso>
        public virtual DeleteCustomerGatewayResponse DeleteCustomerGateway(DeleteCustomerGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteCustomerGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteCustomerGatewayResponseUnmarshaller.Instance;

            return Invoke<DeleteCustomerGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteCustomerGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteCustomerGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteCustomerGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCustomerGateway">REST API Reference for DeleteCustomerGateway Operation</seealso>
        public virtual IAsyncResult BeginDeleteCustomerGateway(DeleteCustomerGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteCustomerGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteCustomerGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteCustomerGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteCustomerGateway.</param>
        /// 
        /// <returns>Returns a  DeleteCustomerGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteCustomerGateway">REST API Reference for DeleteCustomerGateway Operation</seealso>
        public virtual DeleteCustomerGatewayResponse EndDeleteCustomerGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteCustomerGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteDhcpOptions

        /// <summary>
        /// Deletes the specified set of DHCP options. You must disassociate the set of DHCP options
        /// before you can delete it. You can disassociate the set of DHCP options by associating
        /// either a new set of options or the default set of options with the VPC.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteDhcpOptions service method.</param>
        /// 
        /// <returns>The response from the DeleteDhcpOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteDhcpOptions">REST API Reference for DeleteDhcpOptions Operation</seealso>
        public virtual DeleteDhcpOptionsResponse DeleteDhcpOptions(DeleteDhcpOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteDhcpOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteDhcpOptionsResponseUnmarshaller.Instance;

            return Invoke<DeleteDhcpOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteDhcpOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteDhcpOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDhcpOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteDhcpOptions">REST API Reference for DeleteDhcpOptions Operation</seealso>
        public virtual IAsyncResult BeginDeleteDhcpOptions(DeleteDhcpOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteDhcpOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteDhcpOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteDhcpOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteDhcpOptions.</param>
        /// 
        /// <returns>Returns a  DeleteDhcpOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteDhcpOptions">REST API Reference for DeleteDhcpOptions Operation</seealso>
        public virtual DeleteDhcpOptionsResponse EndDeleteDhcpOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteDhcpOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteEgressOnlyInternetGateway

        /// <summary>
        /// Deletes an egress-only internet gateway.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteEgressOnlyInternetGateway service method.</param>
        /// 
        /// <returns>The response from the DeleteEgressOnlyInternetGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteEgressOnlyInternetGateway">REST API Reference for DeleteEgressOnlyInternetGateway Operation</seealso>
        public virtual DeleteEgressOnlyInternetGatewayResponse DeleteEgressOnlyInternetGateway(DeleteEgressOnlyInternetGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteEgressOnlyInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteEgressOnlyInternetGatewayResponseUnmarshaller.Instance;

            return Invoke<DeleteEgressOnlyInternetGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteEgressOnlyInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteEgressOnlyInternetGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteEgressOnlyInternetGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteEgressOnlyInternetGateway">REST API Reference for DeleteEgressOnlyInternetGateway Operation</seealso>
        public virtual IAsyncResult BeginDeleteEgressOnlyInternetGateway(DeleteEgressOnlyInternetGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteEgressOnlyInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteEgressOnlyInternetGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteEgressOnlyInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteEgressOnlyInternetGateway.</param>
        /// 
        /// <returns>Returns a  DeleteEgressOnlyInternetGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteEgressOnlyInternetGateway">REST API Reference for DeleteEgressOnlyInternetGateway Operation</seealso>
        public virtual DeleteEgressOnlyInternetGatewayResponse EndDeleteEgressOnlyInternetGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteEgressOnlyInternetGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteFleets

        /// <summary>
        /// Deletes the specified EC2 Fleets.
        /// 
        ///  
        /// <para>
        /// After you delete an EC2 Fleet, it launches no new instances.
        /// </para>
        ///  
        /// <para>
        /// You must also specify whether a deleted EC2 Fleet should terminate its instances.
        /// If you choose to terminate the instances, the EC2 Fleet enters the <code>deleted_terminating</code>
        /// state. Otherwise, the EC2 Fleet enters the <code>deleted_running</code> state, and
        /// the instances continue to run until they are interrupted or you terminate them manually.
        /// </para>
        ///  
        /// <para>
        /// For <code>instant</code> fleets, EC2 Fleet must terminate the instances when the fleet
        /// is deleted. A deleted <code>instant</code> fleet with running instances is not supported.
        /// </para>
        ///  <p class="title"> <b>Restrictions</b> 
        /// </para>
        ///  <ul> <li> 
        /// <para>
        /// You can delete up to 25 <code>instant</code> fleets in a single request. If you exceed
        /// this number, no <code>instant</code> fleets are deleted and an error is returned.
        /// There is no restriction on the number of fleets of type <code>maintain</code> or <code>request</code>
        /// that can be deleted in a single request.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Up to 1000 instances can be terminated in a single request to delete <code>instant</code>
        /// fleets.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#delete-fleet">Delete
        /// an EC2 Fleet</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteFleets service method.</param>
        /// 
        /// <returns>The response from the DeleteFleets service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFleets">REST API Reference for DeleteFleets Operation</seealso>
        public virtual DeleteFleetsResponse DeleteFleets(DeleteFleetsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteFleetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteFleetsResponseUnmarshaller.Instance;

            return Invoke<DeleteFleetsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteFleets operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteFleets operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteFleets
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFleets">REST API Reference for DeleteFleets Operation</seealso>
        public virtual IAsyncResult BeginDeleteFleets(DeleteFleetsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteFleetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteFleetsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteFleets operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteFleets.</param>
        /// 
        /// <returns>Returns a  DeleteFleetsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFleets">REST API Reference for DeleteFleets Operation</seealso>
        public virtual DeleteFleetsResponse EndDeleteFleets(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteFleetsResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteFlowLogs

        /// <summary>
        /// Deletes one or more flow logs.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteFlowLogs service method.</param>
        /// 
        /// <returns>The response from the DeleteFlowLogs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFlowLogs">REST API Reference for DeleteFlowLogs Operation</seealso>
        public virtual DeleteFlowLogsResponse DeleteFlowLogs(DeleteFlowLogsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteFlowLogsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteFlowLogsResponseUnmarshaller.Instance;

            return Invoke<DeleteFlowLogsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteFlowLogs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteFlowLogs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteFlowLogs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFlowLogs">REST API Reference for DeleteFlowLogs Operation</seealso>
        public virtual IAsyncResult BeginDeleteFlowLogs(DeleteFlowLogsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteFlowLogsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteFlowLogsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteFlowLogs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteFlowLogs.</param>
        /// 
        /// <returns>Returns a  DeleteFlowLogsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFlowLogs">REST API Reference for DeleteFlowLogs Operation</seealso>
        public virtual DeleteFlowLogsResponse EndDeleteFlowLogs(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteFlowLogsResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteFpgaImage

        /// <summary>
        /// Deletes the specified Amazon FPGA Image (AFI).
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteFpgaImage service method.</param>
        /// 
        /// <returns>The response from the DeleteFpgaImage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFpgaImage">REST API Reference for DeleteFpgaImage Operation</seealso>
        public virtual DeleteFpgaImageResponse DeleteFpgaImage(DeleteFpgaImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteFpgaImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteFpgaImageResponseUnmarshaller.Instance;

            return Invoke<DeleteFpgaImageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteFpgaImage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteFpgaImage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteFpgaImage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFpgaImage">REST API Reference for DeleteFpgaImage Operation</seealso>
        public virtual IAsyncResult BeginDeleteFpgaImage(DeleteFpgaImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteFpgaImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteFpgaImageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteFpgaImage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteFpgaImage.</param>
        /// 
        /// <returns>Returns a  DeleteFpgaImageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteFpgaImage">REST API Reference for DeleteFpgaImage Operation</seealso>
        public virtual DeleteFpgaImageResponse EndDeleteFpgaImage(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteFpgaImageResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteInstanceConnectEndpoint

        /// <summary>
        /// Deletes the specified EC2 Instance Connect Endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteInstanceConnectEndpoint service method.</param>
        /// 
        /// <returns>The response from the DeleteInstanceConnectEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInstanceConnectEndpoint">REST API Reference for DeleteInstanceConnectEndpoint Operation</seealso>
        public virtual DeleteInstanceConnectEndpointResponse DeleteInstanceConnectEndpoint(DeleteInstanceConnectEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteInstanceConnectEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteInstanceConnectEndpointResponseUnmarshaller.Instance;

            return Invoke<DeleteInstanceConnectEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteInstanceConnectEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteInstanceConnectEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteInstanceConnectEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInstanceConnectEndpoint">REST API Reference for DeleteInstanceConnectEndpoint Operation</seealso>
        public virtual IAsyncResult BeginDeleteInstanceConnectEndpoint(DeleteInstanceConnectEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteInstanceConnectEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteInstanceConnectEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteInstanceConnectEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteInstanceConnectEndpoint.</param>
        /// 
        /// <returns>Returns a  DeleteInstanceConnectEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInstanceConnectEndpoint">REST API Reference for DeleteInstanceConnectEndpoint Operation</seealso>
        public virtual DeleteInstanceConnectEndpointResponse EndDeleteInstanceConnectEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteInstanceConnectEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteInstanceEventWindow

        /// <summary>
        /// Deletes the specified event window.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
        /// event windows for scheduled events</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteInstanceEventWindow service method.</param>
        /// 
        /// <returns>The response from the DeleteInstanceEventWindow service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInstanceEventWindow">REST API Reference for DeleteInstanceEventWindow Operation</seealso>
        public virtual DeleteInstanceEventWindowResponse DeleteInstanceEventWindow(DeleteInstanceEventWindowRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteInstanceEventWindowResponseUnmarshaller.Instance;

            return Invoke<DeleteInstanceEventWindowResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteInstanceEventWindow operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteInstanceEventWindow
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInstanceEventWindow">REST API Reference for DeleteInstanceEventWindow Operation</seealso>
        public virtual IAsyncResult BeginDeleteInstanceEventWindow(DeleteInstanceEventWindowRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteInstanceEventWindowResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteInstanceEventWindow.</param>
        /// 
        /// <returns>Returns a  DeleteInstanceEventWindowResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInstanceEventWindow">REST API Reference for DeleteInstanceEventWindow Operation</seealso>
        public virtual DeleteInstanceEventWindowResponse EndDeleteInstanceEventWindow(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteInstanceEventWindowResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteInternetGateway

        /// <summary>
        /// Deletes the specified internet gateway. You must detach the internet gateway from
        /// the VPC before you can delete it.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteInternetGateway service method.</param>
        /// 
        /// <returns>The response from the DeleteInternetGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInternetGateway">REST API Reference for DeleteInternetGateway Operation</seealso>
        public virtual DeleteInternetGatewayResponse DeleteInternetGateway(DeleteInternetGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteInternetGatewayResponseUnmarshaller.Instance;

            return Invoke<DeleteInternetGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteInternetGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteInternetGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInternetGateway">REST API Reference for DeleteInternetGateway Operation</seealso>
        public virtual IAsyncResult BeginDeleteInternetGateway(DeleteInternetGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteInternetGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteInternetGateway.</param>
        /// 
        /// <returns>Returns a  DeleteInternetGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteInternetGateway">REST API Reference for DeleteInternetGateway Operation</seealso>
        public virtual DeleteInternetGatewayResponse EndDeleteInternetGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteInternetGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteIpam

        /// <summary>
        /// Delete an IPAM. Deleting an IPAM removes all monitored data associated with the IPAM
        /// including the historical data for CIDRs.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/delete-ipam.html">Delete
        /// an IPAM</a> in the <i>Amazon VPC IPAM User Guide</i>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteIpam service method.</param>
        /// 
        /// <returns>The response from the DeleteIpam service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpam">REST API Reference for DeleteIpam Operation</seealso>
        public virtual DeleteIpamResponse DeleteIpam(DeleteIpamRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpamRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpamResponseUnmarshaller.Instance;

            return Invoke<DeleteIpamResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteIpam operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteIpam operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteIpam
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpam">REST API Reference for DeleteIpam Operation</seealso>
        public virtual IAsyncResult BeginDeleteIpam(DeleteIpamRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpamRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpamResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteIpam operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteIpam.</param>
        /// 
        /// <returns>Returns a  DeleteIpamResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpam">REST API Reference for DeleteIpam Operation</seealso>
        public virtual DeleteIpamResponse EndDeleteIpam(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteIpamResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteIpamPool

        /// <summary>
        /// Delete an IPAM pool.
        /// 
        ///  <note> 
        /// <para>
        /// You cannot delete an IPAM pool if there are allocations in it or CIDRs provisioned
        /// to it. To release allocations, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseIpamPoolAllocation.html">ReleaseIpamPoolAllocation</a>.
        /// To deprovision pool CIDRs, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html">DeprovisionIpamPoolCidr</a>.
        /// </para>
        ///  </note> 
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/delete-pool-ipam.html">Delete
        /// a pool</a> in the <i>Amazon VPC IPAM User Guide</i>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteIpamPool service method.</param>
        /// 
        /// <returns>The response from the DeleteIpamPool service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamPool">REST API Reference for DeleteIpamPool Operation</seealso>
        public virtual DeleteIpamPoolResponse DeleteIpamPool(DeleteIpamPoolRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpamPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpamPoolResponseUnmarshaller.Instance;

            return Invoke<DeleteIpamPoolResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteIpamPool operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteIpamPool operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteIpamPool
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamPool">REST API Reference for DeleteIpamPool Operation</seealso>
        public virtual IAsyncResult BeginDeleteIpamPool(DeleteIpamPoolRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpamPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpamPoolResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteIpamPool operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteIpamPool.</param>
        /// 
        /// <returns>Returns a  DeleteIpamPoolResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamPool">REST API Reference for DeleteIpamPool Operation</seealso>
        public virtual DeleteIpamPoolResponse EndDeleteIpamPool(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteIpamPoolResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteIpamResourceDiscovery

        /// <summary>
        /// Deletes an IPAM resource discovery. A resource discovery is an IPAM component that
        /// enables IPAM to manage and monitor resources that belong to the owning account.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteIpamResourceDiscovery service method.</param>
        /// 
        /// <returns>The response from the DeleteIpamResourceDiscovery service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamResourceDiscovery">REST API Reference for DeleteIpamResourceDiscovery Operation</seealso>
        public virtual DeleteIpamResourceDiscoveryResponse DeleteIpamResourceDiscovery(DeleteIpamResourceDiscoveryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return Invoke<DeleteIpamResourceDiscoveryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteIpamResourceDiscovery operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteIpamResourceDiscovery
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamResourceDiscovery">REST API Reference for DeleteIpamResourceDiscovery Operation</seealso>
        public virtual IAsyncResult BeginDeleteIpamResourceDiscovery(DeleteIpamResourceDiscoveryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteIpamResourceDiscovery.</param>
        /// 
        /// <returns>Returns a  DeleteIpamResourceDiscoveryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamResourceDiscovery">REST API Reference for DeleteIpamResourceDiscovery Operation</seealso>
        public virtual DeleteIpamResourceDiscoveryResponse EndDeleteIpamResourceDiscovery(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteIpamResourceDiscoveryResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteIpamScope

        /// <summary>
        /// Delete the scope for an IPAM. You cannot delete the default scopes.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/delete-scope-ipam.html">Delete
        /// a scope</a> in the <i>Amazon VPC IPAM User Guide</i>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteIpamScope service method.</param>
        /// 
        /// <returns>The response from the DeleteIpamScope service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamScope">REST API Reference for DeleteIpamScope Operation</seealso>
        public virtual DeleteIpamScopeResponse DeleteIpamScope(DeleteIpamScopeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpamScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpamScopeResponseUnmarshaller.Instance;

            return Invoke<DeleteIpamScopeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteIpamScope operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteIpamScope operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteIpamScope
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamScope">REST API Reference for DeleteIpamScope Operation</seealso>
        public virtual IAsyncResult BeginDeleteIpamScope(DeleteIpamScopeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteIpamScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteIpamScopeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteIpamScope operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteIpamScope.</param>
        /// 
        /// <returns>Returns a  DeleteIpamScopeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteIpamScope">REST API Reference for DeleteIpamScope Operation</seealso>
        public virtual DeleteIpamScopeResponse EndDeleteIpamScope(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteIpamScopeResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteKeyPair

        /// <summary>
        /// Deletes the specified key pair, by removing the public key from Amazon EC2.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteKeyPair service method.</param>
        /// 
        /// <returns>The response from the DeleteKeyPair service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteKeyPair">REST API Reference for DeleteKeyPair Operation</seealso>
        public virtual DeleteKeyPairResponse DeleteKeyPair(DeleteKeyPairRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteKeyPairRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteKeyPairResponseUnmarshaller.Instance;

            return Invoke<DeleteKeyPairResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteKeyPair operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteKeyPair operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteKeyPair
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteKeyPair">REST API Reference for DeleteKeyPair Operation</seealso>
        public virtual IAsyncResult BeginDeleteKeyPair(DeleteKeyPairRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteKeyPairRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteKeyPairResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteKeyPair operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteKeyPair.</param>
        /// 
        /// <returns>Returns a  DeleteKeyPairResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteKeyPair">REST API Reference for DeleteKeyPair Operation</seealso>
        public virtual DeleteKeyPairResponse EndDeleteKeyPair(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteKeyPairResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteLaunchTemplate

        /// <summary>
        /// Deletes a launch template. Deleting a launch template deletes all of its versions.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteLaunchTemplate service method.</param>
        /// 
        /// <returns>The response from the DeleteLaunchTemplate service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLaunchTemplate">REST API Reference for DeleteLaunchTemplate Operation</seealso>
        public virtual DeleteLaunchTemplateResponse DeleteLaunchTemplate(DeleteLaunchTemplateRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLaunchTemplateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLaunchTemplateResponseUnmarshaller.Instance;

            return Invoke<DeleteLaunchTemplateResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteLaunchTemplate operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteLaunchTemplate operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLaunchTemplate
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLaunchTemplate">REST API Reference for DeleteLaunchTemplate Operation</seealso>
        public virtual IAsyncResult BeginDeleteLaunchTemplate(DeleteLaunchTemplateRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLaunchTemplateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLaunchTemplateResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteLaunchTemplate operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteLaunchTemplate.</param>
        /// 
        /// <returns>Returns a  DeleteLaunchTemplateResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLaunchTemplate">REST API Reference for DeleteLaunchTemplate Operation</seealso>
        public virtual DeleteLaunchTemplateResponse EndDeleteLaunchTemplate(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteLaunchTemplateResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteLaunchTemplateVersions

        /// <summary>
        /// Deletes one or more versions of a launch template. You cannot delete the default version
        /// of a launch template; you must first assign a different version as the default. If
        /// the default version is the only version for the launch template, you must delete the
        /// entire launch template using <a>DeleteLaunchTemplate</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteLaunchTemplateVersions service method.</param>
        /// 
        /// <returns>The response from the DeleteLaunchTemplateVersions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLaunchTemplateVersions">REST API Reference for DeleteLaunchTemplateVersions Operation</seealso>
        public virtual DeleteLaunchTemplateVersionsResponse DeleteLaunchTemplateVersions(DeleteLaunchTemplateVersionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLaunchTemplateVersionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLaunchTemplateVersionsResponseUnmarshaller.Instance;

            return Invoke<DeleteLaunchTemplateVersionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteLaunchTemplateVersions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteLaunchTemplateVersions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLaunchTemplateVersions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLaunchTemplateVersions">REST API Reference for DeleteLaunchTemplateVersions Operation</seealso>
        public virtual IAsyncResult BeginDeleteLaunchTemplateVersions(DeleteLaunchTemplateVersionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLaunchTemplateVersionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLaunchTemplateVersionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteLaunchTemplateVersions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteLaunchTemplateVersions.</param>
        /// 
        /// <returns>Returns a  DeleteLaunchTemplateVersionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLaunchTemplateVersions">REST API Reference for DeleteLaunchTemplateVersions Operation</seealso>
        public virtual DeleteLaunchTemplateVersionsResponse EndDeleteLaunchTemplateVersions(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteLaunchTemplateVersionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteLocalGatewayRoute

        /// <summary>
        /// Deletes the specified route from the specified local gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteLocalGatewayRoute service method.</param>
        /// 
        /// <returns>The response from the DeleteLocalGatewayRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRoute">REST API Reference for DeleteLocalGatewayRoute Operation</seealso>
        public virtual DeleteLocalGatewayRouteResponse DeleteLocalGatewayRoute(DeleteLocalGatewayRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLocalGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLocalGatewayRouteResponseUnmarshaller.Instance;

            return Invoke<DeleteLocalGatewayRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteLocalGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteLocalGatewayRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLocalGatewayRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRoute">REST API Reference for DeleteLocalGatewayRoute Operation</seealso>
        public virtual IAsyncResult BeginDeleteLocalGatewayRoute(DeleteLocalGatewayRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLocalGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLocalGatewayRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteLocalGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteLocalGatewayRoute.</param>
        /// 
        /// <returns>Returns a  DeleteLocalGatewayRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRoute">REST API Reference for DeleteLocalGatewayRoute Operation</seealso>
        public virtual DeleteLocalGatewayRouteResponse EndDeleteLocalGatewayRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteLocalGatewayRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteLocalGatewayRouteTable

        /// <summary>
        /// Deletes a local gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteLocalGatewayRouteTable service method.</param>
        /// 
        /// <returns>The response from the DeleteLocalGatewayRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTable">REST API Reference for DeleteLocalGatewayRouteTable Operation</seealso>
        public virtual DeleteLocalGatewayRouteTableResponse DeleteLocalGatewayRouteTable(DeleteLocalGatewayRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLocalGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLocalGatewayRouteTableResponseUnmarshaller.Instance;

            return Invoke<DeleteLocalGatewayRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteLocalGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteLocalGatewayRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLocalGatewayRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTable">REST API Reference for DeleteLocalGatewayRouteTable Operation</seealso>
        public virtual IAsyncResult BeginDeleteLocalGatewayRouteTable(DeleteLocalGatewayRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLocalGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLocalGatewayRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteLocalGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteLocalGatewayRouteTable.</param>
        /// 
        /// <returns>Returns a  DeleteLocalGatewayRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTable">REST API Reference for DeleteLocalGatewayRouteTable Operation</seealso>
        public virtual DeleteLocalGatewayRouteTableResponse EndDeleteLocalGatewayRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteLocalGatewayRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation

        /// <summary>
        /// Deletes a local gateway route table virtual interface group association.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation service method.</param>
        /// 
        /// <returns>The response from the DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation">REST API Reference for DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation Operation</seealso>
        public virtual DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponse DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseUnmarshaller.Instance;

            return Invoke<DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation">REST API Reference for DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation Operation</seealso>
        public virtual IAsyncResult BeginDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation.</param>
        /// 
        /// <returns>Returns a  DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation">REST API Reference for DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation Operation</seealso>
        public virtual DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponse EndDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteLocalGatewayRouteTableVpcAssociation

        /// <summary>
        /// Deletes the specified association between a VPC and local gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteLocalGatewayRouteTableVpcAssociation service method.</param>
        /// 
        /// <returns>The response from the DeleteLocalGatewayRouteTableVpcAssociation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTableVpcAssociation">REST API Reference for DeleteLocalGatewayRouteTableVpcAssociation Operation</seealso>
        public virtual DeleteLocalGatewayRouteTableVpcAssociationResponse DeleteLocalGatewayRouteTableVpcAssociation(DeleteLocalGatewayRouteTableVpcAssociationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLocalGatewayRouteTableVpcAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLocalGatewayRouteTableVpcAssociationResponseUnmarshaller.Instance;

            return Invoke<DeleteLocalGatewayRouteTableVpcAssociationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteLocalGatewayRouteTableVpcAssociation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteLocalGatewayRouteTableVpcAssociation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLocalGatewayRouteTableVpcAssociation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTableVpcAssociation">REST API Reference for DeleteLocalGatewayRouteTableVpcAssociation Operation</seealso>
        public virtual IAsyncResult BeginDeleteLocalGatewayRouteTableVpcAssociation(DeleteLocalGatewayRouteTableVpcAssociationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteLocalGatewayRouteTableVpcAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteLocalGatewayRouteTableVpcAssociationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteLocalGatewayRouteTableVpcAssociation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteLocalGatewayRouteTableVpcAssociation.</param>
        /// 
        /// <returns>Returns a  DeleteLocalGatewayRouteTableVpcAssociationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteLocalGatewayRouteTableVpcAssociation">REST API Reference for DeleteLocalGatewayRouteTableVpcAssociation Operation</seealso>
        public virtual DeleteLocalGatewayRouteTableVpcAssociationResponse EndDeleteLocalGatewayRouteTableVpcAssociation(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteLocalGatewayRouteTableVpcAssociationResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteManagedPrefixList

        /// <summary>
        /// Deletes the specified managed prefix list. You must first remove all references to
        /// the prefix list in your resources.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteManagedPrefixList service method.</param>
        /// 
        /// <returns>The response from the DeleteManagedPrefixList service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteManagedPrefixList">REST API Reference for DeleteManagedPrefixList Operation</seealso>
        public virtual DeleteManagedPrefixListResponse DeleteManagedPrefixList(DeleteManagedPrefixListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteManagedPrefixListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteManagedPrefixListResponseUnmarshaller.Instance;

            return Invoke<DeleteManagedPrefixListResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteManagedPrefixList operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteManagedPrefixList operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteManagedPrefixList
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteManagedPrefixList">REST API Reference for DeleteManagedPrefixList Operation</seealso>
        public virtual IAsyncResult BeginDeleteManagedPrefixList(DeleteManagedPrefixListRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteManagedPrefixListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteManagedPrefixListResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteManagedPrefixList operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteManagedPrefixList.</param>
        /// 
        /// <returns>Returns a  DeleteManagedPrefixListResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteManagedPrefixList">REST API Reference for DeleteManagedPrefixList Operation</seealso>
        public virtual DeleteManagedPrefixListResponse EndDeleteManagedPrefixList(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteManagedPrefixListResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteNatGateway

        /// <summary>
        /// Deletes the specified NAT gateway. Deleting a public NAT gateway disassociates its
        /// Elastic IP address, but does not release the address from your account. Deleting a
        /// NAT gateway does not delete any NAT gateway routes in your route tables.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteNatGateway service method.</param>
        /// 
        /// <returns>The response from the DeleteNatGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNatGateway">REST API Reference for DeleteNatGateway Operation</seealso>
        public virtual DeleteNatGatewayResponse DeleteNatGateway(DeleteNatGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNatGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNatGatewayResponseUnmarshaller.Instance;

            return Invoke<DeleteNatGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteNatGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteNatGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNatGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNatGateway">REST API Reference for DeleteNatGateway Operation</seealso>
        public virtual IAsyncResult BeginDeleteNatGateway(DeleteNatGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNatGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNatGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteNatGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteNatGateway.</param>
        /// 
        /// <returns>Returns a  DeleteNatGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNatGateway">REST API Reference for DeleteNatGateway Operation</seealso>
        public virtual DeleteNatGatewayResponse EndDeleteNatGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteNatGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteNetworkAcl

        /// <summary>
        /// Deletes the specified network ACL. You can't delete the ACL if it's associated with
        /// any subnets. You can't delete the default network ACL.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkAcl service method.</param>
        /// 
        /// <returns>The response from the DeleteNetworkAcl service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAcl">REST API Reference for DeleteNetworkAcl Operation</seealso>
        public virtual DeleteNetworkAclResponse DeleteNetworkAcl(DeleteNetworkAclRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkAclRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkAclResponseUnmarshaller.Instance;

            return Invoke<DeleteNetworkAclResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteNetworkAcl operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkAcl operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNetworkAcl
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAcl">REST API Reference for DeleteNetworkAcl Operation</seealso>
        public virtual IAsyncResult BeginDeleteNetworkAcl(DeleteNetworkAclRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkAclRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkAclResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteNetworkAcl operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteNetworkAcl.</param>
        /// 
        /// <returns>Returns a  DeleteNetworkAclResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAcl">REST API Reference for DeleteNetworkAcl Operation</seealso>
        public virtual DeleteNetworkAclResponse EndDeleteNetworkAcl(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteNetworkAclResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteNetworkAclEntry

        /// <summary>
        /// Deletes the specified ingress or egress entry (rule) from the specified network ACL.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkAclEntry service method.</param>
        /// 
        /// <returns>The response from the DeleteNetworkAclEntry service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAclEntry">REST API Reference for DeleteNetworkAclEntry Operation</seealso>
        public virtual DeleteNetworkAclEntryResponse DeleteNetworkAclEntry(DeleteNetworkAclEntryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkAclEntryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkAclEntryResponseUnmarshaller.Instance;

            return Invoke<DeleteNetworkAclEntryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteNetworkAclEntry operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkAclEntry operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNetworkAclEntry
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAclEntry">REST API Reference for DeleteNetworkAclEntry Operation</seealso>
        public virtual IAsyncResult BeginDeleteNetworkAclEntry(DeleteNetworkAclEntryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkAclEntryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkAclEntryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteNetworkAclEntry operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteNetworkAclEntry.</param>
        /// 
        /// <returns>Returns a  DeleteNetworkAclEntryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkAclEntry">REST API Reference for DeleteNetworkAclEntry Operation</seealso>
        public virtual DeleteNetworkAclEntryResponse EndDeleteNetworkAclEntry(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteNetworkAclEntryResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteNetworkInsightsAccessScope

        /// <summary>
        /// Deletes the specified Network Access Scope.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInsightsAccessScope service method.</param>
        /// 
        /// <returns>The response from the DeleteNetworkInsightsAccessScope service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAccessScope">REST API Reference for DeleteNetworkInsightsAccessScope Operation</seealso>
        public virtual DeleteNetworkInsightsAccessScopeResponse DeleteNetworkInsightsAccessScope(DeleteNetworkInsightsAccessScopeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInsightsAccessScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInsightsAccessScopeResponseUnmarshaller.Instance;

            return Invoke<DeleteNetworkInsightsAccessScopeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteNetworkInsightsAccessScope operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInsightsAccessScope operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNetworkInsightsAccessScope
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAccessScope">REST API Reference for DeleteNetworkInsightsAccessScope Operation</seealso>
        public virtual IAsyncResult BeginDeleteNetworkInsightsAccessScope(DeleteNetworkInsightsAccessScopeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInsightsAccessScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInsightsAccessScopeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteNetworkInsightsAccessScope operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteNetworkInsightsAccessScope.</param>
        /// 
        /// <returns>Returns a  DeleteNetworkInsightsAccessScopeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAccessScope">REST API Reference for DeleteNetworkInsightsAccessScope Operation</seealso>
        public virtual DeleteNetworkInsightsAccessScopeResponse EndDeleteNetworkInsightsAccessScope(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteNetworkInsightsAccessScopeResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteNetworkInsightsAccessScopeAnalysis

        /// <summary>
        /// Deletes the specified Network Access Scope analysis.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInsightsAccessScopeAnalysis service method.</param>
        /// 
        /// <returns>The response from the DeleteNetworkInsightsAccessScopeAnalysis service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAccessScopeAnalysis">REST API Reference for DeleteNetworkInsightsAccessScopeAnalysis Operation</seealso>
        public virtual DeleteNetworkInsightsAccessScopeAnalysisResponse DeleteNetworkInsightsAccessScopeAnalysis(DeleteNetworkInsightsAccessScopeAnalysisRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInsightsAccessScopeAnalysisRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInsightsAccessScopeAnalysisResponseUnmarshaller.Instance;

            return Invoke<DeleteNetworkInsightsAccessScopeAnalysisResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteNetworkInsightsAccessScopeAnalysis operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInsightsAccessScopeAnalysis operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNetworkInsightsAccessScopeAnalysis
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAccessScopeAnalysis">REST API Reference for DeleteNetworkInsightsAccessScopeAnalysis Operation</seealso>
        public virtual IAsyncResult BeginDeleteNetworkInsightsAccessScopeAnalysis(DeleteNetworkInsightsAccessScopeAnalysisRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInsightsAccessScopeAnalysisRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInsightsAccessScopeAnalysisResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteNetworkInsightsAccessScopeAnalysis operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteNetworkInsightsAccessScopeAnalysis.</param>
        /// 
        /// <returns>Returns a  DeleteNetworkInsightsAccessScopeAnalysisResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAccessScopeAnalysis">REST API Reference for DeleteNetworkInsightsAccessScopeAnalysis Operation</seealso>
        public virtual DeleteNetworkInsightsAccessScopeAnalysisResponse EndDeleteNetworkInsightsAccessScopeAnalysis(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteNetworkInsightsAccessScopeAnalysisResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteNetworkInsightsAnalysis

        /// <summary>
        /// Deletes the specified network insights analysis.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInsightsAnalysis service method.</param>
        /// 
        /// <returns>The response from the DeleteNetworkInsightsAnalysis service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAnalysis">REST API Reference for DeleteNetworkInsightsAnalysis Operation</seealso>
        public virtual DeleteNetworkInsightsAnalysisResponse DeleteNetworkInsightsAnalysis(DeleteNetworkInsightsAnalysisRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInsightsAnalysisRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInsightsAnalysisResponseUnmarshaller.Instance;

            return Invoke<DeleteNetworkInsightsAnalysisResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteNetworkInsightsAnalysis operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInsightsAnalysis operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNetworkInsightsAnalysis
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAnalysis">REST API Reference for DeleteNetworkInsightsAnalysis Operation</seealso>
        public virtual IAsyncResult BeginDeleteNetworkInsightsAnalysis(DeleteNetworkInsightsAnalysisRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInsightsAnalysisRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInsightsAnalysisResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteNetworkInsightsAnalysis operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteNetworkInsightsAnalysis.</param>
        /// 
        /// <returns>Returns a  DeleteNetworkInsightsAnalysisResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsAnalysis">REST API Reference for DeleteNetworkInsightsAnalysis Operation</seealso>
        public virtual DeleteNetworkInsightsAnalysisResponse EndDeleteNetworkInsightsAnalysis(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteNetworkInsightsAnalysisResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteNetworkInsightsPath

        /// <summary>
        /// Deletes the specified path.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInsightsPath service method.</param>
        /// 
        /// <returns>The response from the DeleteNetworkInsightsPath service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsPath">REST API Reference for DeleteNetworkInsightsPath Operation</seealso>
        public virtual DeleteNetworkInsightsPathResponse DeleteNetworkInsightsPath(DeleteNetworkInsightsPathRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInsightsPathRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInsightsPathResponseUnmarshaller.Instance;

            return Invoke<DeleteNetworkInsightsPathResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteNetworkInsightsPath operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInsightsPath operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNetworkInsightsPath
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsPath">REST API Reference for DeleteNetworkInsightsPath Operation</seealso>
        public virtual IAsyncResult BeginDeleteNetworkInsightsPath(DeleteNetworkInsightsPathRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInsightsPathRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInsightsPathResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteNetworkInsightsPath operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteNetworkInsightsPath.</param>
        /// 
        /// <returns>Returns a  DeleteNetworkInsightsPathResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInsightsPath">REST API Reference for DeleteNetworkInsightsPath Operation</seealso>
        public virtual DeleteNetworkInsightsPathResponse EndDeleteNetworkInsightsPath(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteNetworkInsightsPathResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteNetworkInterface

        /// <summary>
        /// Deletes the specified network interface. You must detach the network interface before
        /// you can delete it.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInterface service method.</param>
        /// 
        /// <returns>The response from the DeleteNetworkInterface service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterface">REST API Reference for DeleteNetworkInterface Operation</seealso>
        public virtual DeleteNetworkInterfaceResponse DeleteNetworkInterface(DeleteNetworkInterfaceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInterfaceResponseUnmarshaller.Instance;

            return Invoke<DeleteNetworkInterfaceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteNetworkInterface operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInterface operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNetworkInterface
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterface">REST API Reference for DeleteNetworkInterface Operation</seealso>
        public virtual IAsyncResult BeginDeleteNetworkInterface(DeleteNetworkInterfaceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInterfaceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteNetworkInterface operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteNetworkInterface.</param>
        /// 
        /// <returns>Returns a  DeleteNetworkInterfaceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterface">REST API Reference for DeleteNetworkInterface Operation</seealso>
        public virtual DeleteNetworkInterfaceResponse EndDeleteNetworkInterface(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteNetworkInterfaceResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteNetworkInterfacePermission

        /// <summary>
        /// Deletes a permission for a network interface. By default, you cannot delete the permission
        /// if the account for which you're removing the permission has attached the network interface
        /// to an instance. However, you can force delete the permission, regardless of any attachment.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInterfacePermission service method.</param>
        /// 
        /// <returns>The response from the DeleteNetworkInterfacePermission service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterfacePermission">REST API Reference for DeleteNetworkInterfacePermission Operation</seealso>
        public virtual DeleteNetworkInterfacePermissionResponse DeleteNetworkInterfacePermission(DeleteNetworkInterfacePermissionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInterfacePermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInterfacePermissionResponseUnmarshaller.Instance;

            return Invoke<DeleteNetworkInterfacePermissionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteNetworkInterfacePermission operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteNetworkInterfacePermission operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteNetworkInterfacePermission
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterfacePermission">REST API Reference for DeleteNetworkInterfacePermission Operation</seealso>
        public virtual IAsyncResult BeginDeleteNetworkInterfacePermission(DeleteNetworkInterfacePermissionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteNetworkInterfacePermissionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteNetworkInterfacePermissionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteNetworkInterfacePermission operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteNetworkInterfacePermission.</param>
        /// 
        /// <returns>Returns a  DeleteNetworkInterfacePermissionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteNetworkInterfacePermission">REST API Reference for DeleteNetworkInterfacePermission Operation</seealso>
        public virtual DeleteNetworkInterfacePermissionResponse EndDeleteNetworkInterfacePermission(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteNetworkInterfacePermissionResponse>(asyncResult);
        }

        #endregion
        
        #region  DeletePlacementGroup

        /// <summary>
        /// Deletes the specified placement group. You must terminate all instances in the placement
        /// group before you can delete the placement group. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">Placement
        /// groups</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeletePlacementGroup service method.</param>
        /// 
        /// <returns>The response from the DeletePlacementGroup service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePlacementGroup">REST API Reference for DeletePlacementGroup Operation</seealso>
        public virtual DeletePlacementGroupResponse DeletePlacementGroup(DeletePlacementGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeletePlacementGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeletePlacementGroupResponseUnmarshaller.Instance;

            return Invoke<DeletePlacementGroupResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeletePlacementGroup operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeletePlacementGroup operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeletePlacementGroup
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePlacementGroup">REST API Reference for DeletePlacementGroup Operation</seealso>
        public virtual IAsyncResult BeginDeletePlacementGroup(DeletePlacementGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeletePlacementGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeletePlacementGroupResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeletePlacementGroup operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeletePlacementGroup.</param>
        /// 
        /// <returns>Returns a  DeletePlacementGroupResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePlacementGroup">REST API Reference for DeletePlacementGroup Operation</seealso>
        public virtual DeletePlacementGroupResponse EndDeletePlacementGroup(IAsyncResult asyncResult)
        {
            return EndInvoke<DeletePlacementGroupResponse>(asyncResult);
        }

        #endregion
        
        #region  DeletePublicIpv4Pool

        /// <summary>
        /// Delete a public IPv4 pool. A public IPv4 pool is an EC2 IP address pool required for
        /// the public IPv4 CIDRs that you own and bring to Amazon Web Services to manage with
        /// IPAM. IPv6 addresses you bring to Amazon Web Services, however, use IPAM pools only.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeletePublicIpv4Pool service method.</param>
        /// 
        /// <returns>The response from the DeletePublicIpv4Pool service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePublicIpv4Pool">REST API Reference for DeletePublicIpv4Pool Operation</seealso>
        public virtual DeletePublicIpv4PoolResponse DeletePublicIpv4Pool(DeletePublicIpv4PoolRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeletePublicIpv4PoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeletePublicIpv4PoolResponseUnmarshaller.Instance;

            return Invoke<DeletePublicIpv4PoolResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeletePublicIpv4Pool operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeletePublicIpv4Pool operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeletePublicIpv4Pool
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePublicIpv4Pool">REST API Reference for DeletePublicIpv4Pool Operation</seealso>
        public virtual IAsyncResult BeginDeletePublicIpv4Pool(DeletePublicIpv4PoolRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeletePublicIpv4PoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeletePublicIpv4PoolResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeletePublicIpv4Pool operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeletePublicIpv4Pool.</param>
        /// 
        /// <returns>Returns a  DeletePublicIpv4PoolResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeletePublicIpv4Pool">REST API Reference for DeletePublicIpv4Pool Operation</seealso>
        public virtual DeletePublicIpv4PoolResponse EndDeletePublicIpv4Pool(IAsyncResult asyncResult)
        {
            return EndInvoke<DeletePublicIpv4PoolResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteQueuedReservedInstances

        /// <summary>
        /// Deletes the queued purchases for the specified Reserved Instances.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteQueuedReservedInstances service method.</param>
        /// 
        /// <returns>The response from the DeleteQueuedReservedInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteQueuedReservedInstances">REST API Reference for DeleteQueuedReservedInstances Operation</seealso>
        public virtual DeleteQueuedReservedInstancesResponse DeleteQueuedReservedInstances(DeleteQueuedReservedInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteQueuedReservedInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteQueuedReservedInstancesResponseUnmarshaller.Instance;

            return Invoke<DeleteQueuedReservedInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteQueuedReservedInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteQueuedReservedInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteQueuedReservedInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteQueuedReservedInstances">REST API Reference for DeleteQueuedReservedInstances Operation</seealso>
        public virtual IAsyncResult BeginDeleteQueuedReservedInstances(DeleteQueuedReservedInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteQueuedReservedInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteQueuedReservedInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteQueuedReservedInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteQueuedReservedInstances.</param>
        /// 
        /// <returns>Returns a  DeleteQueuedReservedInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteQueuedReservedInstances">REST API Reference for DeleteQueuedReservedInstances Operation</seealso>
        public virtual DeleteQueuedReservedInstancesResponse EndDeleteQueuedReservedInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteQueuedReservedInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteRoute

        /// <summary>
        /// Deletes the specified route from the specified route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteRoute service method.</param>
        /// 
        /// <returns>The response from the DeleteRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRoute">REST API Reference for DeleteRoute Operation</seealso>
        public virtual DeleteRouteResponse DeleteRoute(DeleteRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteRouteResponseUnmarshaller.Instance;

            return Invoke<DeleteRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRoute">REST API Reference for DeleteRoute Operation</seealso>
        public virtual IAsyncResult BeginDeleteRoute(DeleteRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteRoute.</param>
        /// 
        /// <returns>Returns a  DeleteRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRoute">REST API Reference for DeleteRoute Operation</seealso>
        public virtual DeleteRouteResponse EndDeleteRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteRouteTable

        /// <summary>
        /// Deletes the specified route table. You must disassociate the route table from any
        /// subnets before you can delete it. You can't delete the main route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteRouteTable service method.</param>
        /// 
        /// <returns>The response from the DeleteRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRouteTable">REST API Reference for DeleteRouteTable Operation</seealso>
        public virtual DeleteRouteTableResponse DeleteRouteTable(DeleteRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteRouteTableResponseUnmarshaller.Instance;

            return Invoke<DeleteRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRouteTable">REST API Reference for DeleteRouteTable Operation</seealso>
        public virtual IAsyncResult BeginDeleteRouteTable(DeleteRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteRouteTable.</param>
        /// 
        /// <returns>Returns a  DeleteRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteRouteTable">REST API Reference for DeleteRouteTable Operation</seealso>
        public virtual DeleteRouteTableResponse EndDeleteRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteSecurityGroup

        /// <summary>
        /// Deletes a security group.
        /// 
        ///  
        /// <para>
        /// If you attempt to delete a security group that is associated with an instance or network
        /// interface or is referenced by another security group, the operation fails with <code>DependencyViolation</code>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteSecurityGroup service method.</param>
        /// 
        /// <returns>The response from the DeleteSecurityGroup service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSecurityGroup">REST API Reference for DeleteSecurityGroup Operation</seealso>
        public virtual DeleteSecurityGroupResponse DeleteSecurityGroup(DeleteSecurityGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSecurityGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSecurityGroupResponseUnmarshaller.Instance;

            return Invoke<DeleteSecurityGroupResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteSecurityGroup operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteSecurityGroup operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSecurityGroup
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSecurityGroup">REST API Reference for DeleteSecurityGroup Operation</seealso>
        public virtual IAsyncResult BeginDeleteSecurityGroup(DeleteSecurityGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSecurityGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSecurityGroupResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteSecurityGroup operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteSecurityGroup.</param>
        /// 
        /// <returns>Returns a  DeleteSecurityGroupResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSecurityGroup">REST API Reference for DeleteSecurityGroup Operation</seealso>
        public virtual DeleteSecurityGroupResponse EndDeleteSecurityGroup(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteSecurityGroupResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteSnapshot

        /// <summary>
        /// Deletes the specified snapshot.
        /// 
        ///  
        /// <para>
        /// When you make periodic snapshots of a volume, the snapshots are incremental, and only
        /// the blocks on the device that have changed since your last snapshot are saved in the
        /// new snapshot. When you delete a snapshot, only the data not needed for any other snapshot
        /// is removed. So regardless of which prior snapshots have been deleted, all active snapshots
        /// will have access to all the information needed to restore the volume.
        /// </para>
        ///  
        /// <para>
        /// You cannot delete a snapshot of the root device of an EBS volume used by a registered
        /// AMI. You must first de-register the AMI before you can delete the snapshot.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-deleting-snapshot.html">Delete
        /// an Amazon EBS snapshot</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteSnapshot service method.</param>
        /// 
        /// <returns>The response from the DeleteSnapshot service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSnapshot">REST API Reference for DeleteSnapshot Operation</seealso>
        public virtual DeleteSnapshotResponse DeleteSnapshot(DeleteSnapshotRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance;

            return Invoke<DeleteSnapshotResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteSnapshot operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteSnapshot operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSnapshot
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSnapshot">REST API Reference for DeleteSnapshot Operation</seealso>
        public virtual IAsyncResult BeginDeleteSnapshot(DeleteSnapshotRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteSnapshot operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteSnapshot.</param>
        /// 
        /// <returns>Returns a  DeleteSnapshotResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSnapshot">REST API Reference for DeleteSnapshot Operation</seealso>
        public virtual DeleteSnapshotResponse EndDeleteSnapshot(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteSnapshotResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteSpotDatafeedSubscription

        /// <summary>
        /// Deletes the data feed for Spot Instances.
        /// </summary>
        /// 
        /// <returns>The response from the DeleteSpotDatafeedSubscription service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSpotDatafeedSubscription">REST API Reference for DeleteSpotDatafeedSubscription Operation</seealso>
        public virtual DeleteSpotDatafeedSubscriptionResponse DeleteSpotDatafeedSubscription()
        {
            return DeleteSpotDatafeedSubscription(new DeleteSpotDatafeedSubscriptionRequest());
        }

        /// <summary>
        /// Deletes the data feed for Spot Instances.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteSpotDatafeedSubscription service method.</param>
        /// 
        /// <returns>The response from the DeleteSpotDatafeedSubscription service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSpotDatafeedSubscription">REST API Reference for DeleteSpotDatafeedSubscription Operation</seealso>
        public virtual DeleteSpotDatafeedSubscriptionResponse DeleteSpotDatafeedSubscription(DeleteSpotDatafeedSubscriptionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSpotDatafeedSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSpotDatafeedSubscriptionResponseUnmarshaller.Instance;

            return Invoke<DeleteSpotDatafeedSubscriptionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteSpotDatafeedSubscription operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteSpotDatafeedSubscription operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSpotDatafeedSubscription
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSpotDatafeedSubscription">REST API Reference for DeleteSpotDatafeedSubscription Operation</seealso>
        public virtual IAsyncResult BeginDeleteSpotDatafeedSubscription(DeleteSpotDatafeedSubscriptionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSpotDatafeedSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSpotDatafeedSubscriptionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteSpotDatafeedSubscription operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteSpotDatafeedSubscription.</param>
        /// 
        /// <returns>Returns a  DeleteSpotDatafeedSubscriptionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSpotDatafeedSubscription">REST API Reference for DeleteSpotDatafeedSubscription Operation</seealso>
        public virtual DeleteSpotDatafeedSubscriptionResponse EndDeleteSpotDatafeedSubscription(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteSpotDatafeedSubscriptionResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteSubnet

        /// <summary>
        /// Deletes the specified subnet. You must terminate all running instances in the subnet
        /// before you can delete the subnet.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteSubnet service method.</param>
        /// 
        /// <returns>The response from the DeleteSubnet service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnet">REST API Reference for DeleteSubnet Operation</seealso>
        public virtual DeleteSubnetResponse DeleteSubnet(DeleteSubnetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSubnetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSubnetResponseUnmarshaller.Instance;

            return Invoke<DeleteSubnetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteSubnet operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteSubnet operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSubnet
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnet">REST API Reference for DeleteSubnet Operation</seealso>
        public virtual IAsyncResult BeginDeleteSubnet(DeleteSubnetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSubnetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSubnetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteSubnet operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteSubnet.</param>
        /// 
        /// <returns>Returns a  DeleteSubnetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnet">REST API Reference for DeleteSubnet Operation</seealso>
        public virtual DeleteSubnetResponse EndDeleteSubnet(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteSubnetResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteSubnetCidrReservation

        /// <summary>
        /// Deletes a subnet CIDR reservation.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteSubnetCidrReservation service method.</param>
        /// 
        /// <returns>The response from the DeleteSubnetCidrReservation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnetCidrReservation">REST API Reference for DeleteSubnetCidrReservation Operation</seealso>
        public virtual DeleteSubnetCidrReservationResponse DeleteSubnetCidrReservation(DeleteSubnetCidrReservationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSubnetCidrReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSubnetCidrReservationResponseUnmarshaller.Instance;

            return Invoke<DeleteSubnetCidrReservationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteSubnetCidrReservation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteSubnetCidrReservation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSubnetCidrReservation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnetCidrReservation">REST API Reference for DeleteSubnetCidrReservation Operation</seealso>
        public virtual IAsyncResult BeginDeleteSubnetCidrReservation(DeleteSubnetCidrReservationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteSubnetCidrReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteSubnetCidrReservationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteSubnetCidrReservation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteSubnetCidrReservation.</param>
        /// 
        /// <returns>Returns a  DeleteSubnetCidrReservationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteSubnetCidrReservation">REST API Reference for DeleteSubnetCidrReservation Operation</seealso>
        public virtual DeleteSubnetCidrReservationResponse EndDeleteSubnetCidrReservation(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteSubnetCidrReservationResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTags

        /// <summary>
        /// Deletes the specified set of tags from the specified set of resources.
        /// 
        ///  
        /// <para>
        /// To list the current tags, use <a>DescribeTags</a>. For more information about tags,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
        /// your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTags service method.</param>
        /// 
        /// <returns>The response from the DeleteTags service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTags">REST API Reference for DeleteTags Operation</seealso>
        public virtual DeleteTagsResponse DeleteTags(DeleteTagsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTagsResponseUnmarshaller.Instance;

            return Invoke<DeleteTagsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTags operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTags operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTags
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTags">REST API Reference for DeleteTags Operation</seealso>
        public virtual IAsyncResult BeginDeleteTags(DeleteTagsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTagsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTags operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTags.</param>
        /// 
        /// <returns>Returns a  DeleteTagsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTags">REST API Reference for DeleteTags Operation</seealso>
        public virtual DeleteTagsResponse EndDeleteTags(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTagsResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTrafficMirrorFilter

        /// <summary>
        /// Deletes the specified Traffic Mirror filter.
        /// 
        ///  
        /// <para>
        /// You cannot delete a Traffic Mirror filter that is in use by a Traffic Mirror session.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTrafficMirrorFilter service method.</param>
        /// 
        /// <returns>The response from the DeleteTrafficMirrorFilter service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorFilter">REST API Reference for DeleteTrafficMirrorFilter Operation</seealso>
        public virtual DeleteTrafficMirrorFilterResponse DeleteTrafficMirrorFilter(DeleteTrafficMirrorFilterRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTrafficMirrorFilterRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTrafficMirrorFilterResponseUnmarshaller.Instance;

            return Invoke<DeleteTrafficMirrorFilterResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTrafficMirrorFilter operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTrafficMirrorFilter operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTrafficMirrorFilter
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorFilter">REST API Reference for DeleteTrafficMirrorFilter Operation</seealso>
        public virtual IAsyncResult BeginDeleteTrafficMirrorFilter(DeleteTrafficMirrorFilterRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTrafficMirrorFilterRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTrafficMirrorFilterResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTrafficMirrorFilter operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTrafficMirrorFilter.</param>
        /// 
        /// <returns>Returns a  DeleteTrafficMirrorFilterResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorFilter">REST API Reference for DeleteTrafficMirrorFilter Operation</seealso>
        public virtual DeleteTrafficMirrorFilterResponse EndDeleteTrafficMirrorFilter(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTrafficMirrorFilterResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTrafficMirrorFilterRule

        /// <summary>
        /// Deletes the specified Traffic Mirror rule.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTrafficMirrorFilterRule service method.</param>
        /// 
        /// <returns>The response from the DeleteTrafficMirrorFilterRule service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorFilterRule">REST API Reference for DeleteTrafficMirrorFilterRule Operation</seealso>
        public virtual DeleteTrafficMirrorFilterRuleResponse DeleteTrafficMirrorFilterRule(DeleteTrafficMirrorFilterRuleRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTrafficMirrorFilterRuleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTrafficMirrorFilterRuleResponseUnmarshaller.Instance;

            return Invoke<DeleteTrafficMirrorFilterRuleResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTrafficMirrorFilterRule operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTrafficMirrorFilterRule operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTrafficMirrorFilterRule
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorFilterRule">REST API Reference for DeleteTrafficMirrorFilterRule Operation</seealso>
        public virtual IAsyncResult BeginDeleteTrafficMirrorFilterRule(DeleteTrafficMirrorFilterRuleRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTrafficMirrorFilterRuleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTrafficMirrorFilterRuleResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTrafficMirrorFilterRule operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTrafficMirrorFilterRule.</param>
        /// 
        /// <returns>Returns a  DeleteTrafficMirrorFilterRuleResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorFilterRule">REST API Reference for DeleteTrafficMirrorFilterRule Operation</seealso>
        public virtual DeleteTrafficMirrorFilterRuleResponse EndDeleteTrafficMirrorFilterRule(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTrafficMirrorFilterRuleResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTrafficMirrorSession

        /// <summary>
        /// Deletes the specified Traffic Mirror session.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTrafficMirrorSession service method.</param>
        /// 
        /// <returns>The response from the DeleteTrafficMirrorSession service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorSession">REST API Reference for DeleteTrafficMirrorSession Operation</seealso>
        public virtual DeleteTrafficMirrorSessionResponse DeleteTrafficMirrorSession(DeleteTrafficMirrorSessionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTrafficMirrorSessionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTrafficMirrorSessionResponseUnmarshaller.Instance;

            return Invoke<DeleteTrafficMirrorSessionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTrafficMirrorSession operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTrafficMirrorSession operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTrafficMirrorSession
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorSession">REST API Reference for DeleteTrafficMirrorSession Operation</seealso>
        public virtual IAsyncResult BeginDeleteTrafficMirrorSession(DeleteTrafficMirrorSessionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTrafficMirrorSessionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTrafficMirrorSessionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTrafficMirrorSession operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTrafficMirrorSession.</param>
        /// 
        /// <returns>Returns a  DeleteTrafficMirrorSessionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorSession">REST API Reference for DeleteTrafficMirrorSession Operation</seealso>
        public virtual DeleteTrafficMirrorSessionResponse EndDeleteTrafficMirrorSession(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTrafficMirrorSessionResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTrafficMirrorTarget

        /// <summary>
        /// Deletes the specified Traffic Mirror target.
        /// 
        ///  
        /// <para>
        /// You cannot delete a Traffic Mirror target that is in use by a Traffic Mirror session.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTrafficMirrorTarget service method.</param>
        /// 
        /// <returns>The response from the DeleteTrafficMirrorTarget service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorTarget">REST API Reference for DeleteTrafficMirrorTarget Operation</seealso>
        public virtual DeleteTrafficMirrorTargetResponse DeleteTrafficMirrorTarget(DeleteTrafficMirrorTargetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTrafficMirrorTargetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTrafficMirrorTargetResponseUnmarshaller.Instance;

            return Invoke<DeleteTrafficMirrorTargetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTrafficMirrorTarget operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTrafficMirrorTarget operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTrafficMirrorTarget
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorTarget">REST API Reference for DeleteTrafficMirrorTarget Operation</seealso>
        public virtual IAsyncResult BeginDeleteTrafficMirrorTarget(DeleteTrafficMirrorTargetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTrafficMirrorTargetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTrafficMirrorTargetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTrafficMirrorTarget operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTrafficMirrorTarget.</param>
        /// 
        /// <returns>Returns a  DeleteTrafficMirrorTargetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTrafficMirrorTarget">REST API Reference for DeleteTrafficMirrorTarget Operation</seealso>
        public virtual DeleteTrafficMirrorTargetResponse EndDeleteTrafficMirrorTarget(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTrafficMirrorTargetResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGateway

        /// <summary>
        /// Deletes the specified transit gateway.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGateway service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGateway">REST API Reference for DeleteTransitGateway Operation</seealso>
        public virtual DeleteTransitGatewayResponse DeleteTransitGateway(DeleteTransitGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGateway">REST API Reference for DeleteTransitGateway Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGateway(DeleteTransitGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGateway.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGateway">REST API Reference for DeleteTransitGateway Operation</seealso>
        public virtual DeleteTransitGatewayResponse EndDeleteTransitGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayConnect

        /// <summary>
        /// Deletes the specified Connect attachment. You must first delete any Connect peers
        /// for the attachment.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayConnect service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayConnect service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayConnect">REST API Reference for DeleteTransitGatewayConnect Operation</seealso>
        public virtual DeleteTransitGatewayConnectResponse DeleteTransitGatewayConnect(DeleteTransitGatewayConnectRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayConnectRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayConnectResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayConnectResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayConnect operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayConnect operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayConnect
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayConnect">REST API Reference for DeleteTransitGatewayConnect Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayConnect(DeleteTransitGatewayConnectRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayConnectRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayConnectResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayConnect operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayConnect.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayConnectResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayConnect">REST API Reference for DeleteTransitGatewayConnect Operation</seealso>
        public virtual DeleteTransitGatewayConnectResponse EndDeleteTransitGatewayConnect(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayConnectResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayConnectPeer

        /// <summary>
        /// Deletes the specified Connect peer.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayConnectPeer service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayConnectPeer service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayConnectPeer">REST API Reference for DeleteTransitGatewayConnectPeer Operation</seealso>
        public virtual DeleteTransitGatewayConnectPeerResponse DeleteTransitGatewayConnectPeer(DeleteTransitGatewayConnectPeerRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayConnectPeerRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayConnectPeerResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayConnectPeerResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayConnectPeer operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayConnectPeer operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayConnectPeer
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayConnectPeer">REST API Reference for DeleteTransitGatewayConnectPeer Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayConnectPeer(DeleteTransitGatewayConnectPeerRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayConnectPeerRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayConnectPeerResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayConnectPeer operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayConnectPeer.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayConnectPeerResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayConnectPeer">REST API Reference for DeleteTransitGatewayConnectPeer Operation</seealso>
        public virtual DeleteTransitGatewayConnectPeerResponse EndDeleteTransitGatewayConnectPeer(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayConnectPeerResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayMulticastDomain

        /// <summary>
        /// Deletes the specified transit gateway multicast domain.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayMulticastDomain service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayMulticastDomain service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayMulticastDomain">REST API Reference for DeleteTransitGatewayMulticastDomain Operation</seealso>
        public virtual DeleteTransitGatewayMulticastDomainResponse DeleteTransitGatewayMulticastDomain(DeleteTransitGatewayMulticastDomainRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayMulticastDomainRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayMulticastDomainResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayMulticastDomainResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayMulticastDomain operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayMulticastDomain operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayMulticastDomain
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayMulticastDomain">REST API Reference for DeleteTransitGatewayMulticastDomain Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayMulticastDomain(DeleteTransitGatewayMulticastDomainRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayMulticastDomainRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayMulticastDomainResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayMulticastDomain operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayMulticastDomain.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayMulticastDomainResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayMulticastDomain">REST API Reference for DeleteTransitGatewayMulticastDomain Operation</seealso>
        public virtual DeleteTransitGatewayMulticastDomainResponse EndDeleteTransitGatewayMulticastDomain(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayMulticastDomainResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayPeeringAttachment

        /// <summary>
        /// Deletes a transit gateway peering attachment.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayPeeringAttachment service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayPeeringAttachment service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPeeringAttachment">REST API Reference for DeleteTransitGatewayPeeringAttachment Operation</seealso>
        public virtual DeleteTransitGatewayPeeringAttachmentResponse DeleteTransitGatewayPeeringAttachment(DeleteTransitGatewayPeeringAttachmentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayPeeringAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayPeeringAttachmentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayPeeringAttachment operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayPeeringAttachment operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayPeeringAttachment
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPeeringAttachment">REST API Reference for DeleteTransitGatewayPeeringAttachment Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayPeeringAttachment(DeleteTransitGatewayPeeringAttachmentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayPeeringAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayPeeringAttachment operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayPeeringAttachment.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayPeeringAttachmentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPeeringAttachment">REST API Reference for DeleteTransitGatewayPeeringAttachment Operation</seealso>
        public virtual DeleteTransitGatewayPeeringAttachmentResponse EndDeleteTransitGatewayPeeringAttachment(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayPeeringAttachmentResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayPolicyTable

        /// <summary>
        /// Deletes the specified transit gateway policy table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayPolicyTable service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayPolicyTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPolicyTable">REST API Reference for DeleteTransitGatewayPolicyTable Operation</seealso>
        public virtual DeleteTransitGatewayPolicyTableResponse DeleteTransitGatewayPolicyTable(DeleteTransitGatewayPolicyTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayPolicyTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayPolicyTableResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayPolicyTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayPolicyTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayPolicyTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayPolicyTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPolicyTable">REST API Reference for DeleteTransitGatewayPolicyTable Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayPolicyTable(DeleteTransitGatewayPolicyTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayPolicyTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayPolicyTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayPolicyTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayPolicyTable.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayPolicyTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPolicyTable">REST API Reference for DeleteTransitGatewayPolicyTable Operation</seealso>
        public virtual DeleteTransitGatewayPolicyTableResponse EndDeleteTransitGatewayPolicyTable(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayPolicyTableResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayPrefixListReference

        /// <summary>
        /// Deletes a reference (route) to a prefix list in a specified transit gateway route
        /// table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayPrefixListReference service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayPrefixListReference service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPrefixListReference">REST API Reference for DeleteTransitGatewayPrefixListReference Operation</seealso>
        public virtual DeleteTransitGatewayPrefixListReferenceResponse DeleteTransitGatewayPrefixListReference(DeleteTransitGatewayPrefixListReferenceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayPrefixListReferenceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayPrefixListReferenceResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayPrefixListReferenceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayPrefixListReference operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayPrefixListReference operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayPrefixListReference
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPrefixListReference">REST API Reference for DeleteTransitGatewayPrefixListReference Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayPrefixListReference(DeleteTransitGatewayPrefixListReferenceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayPrefixListReferenceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayPrefixListReferenceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayPrefixListReference operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayPrefixListReference.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayPrefixListReferenceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayPrefixListReference">REST API Reference for DeleteTransitGatewayPrefixListReference Operation</seealso>
        public virtual DeleteTransitGatewayPrefixListReferenceResponse EndDeleteTransitGatewayPrefixListReference(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayPrefixListReferenceResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayRoute

        /// <summary>
        /// Deletes the specified route from the specified transit gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayRoute service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRoute">REST API Reference for DeleteTransitGatewayRoute Operation</seealso>
        public virtual DeleteTransitGatewayRouteResponse DeleteTransitGatewayRoute(DeleteTransitGatewayRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayRouteResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRoute">REST API Reference for DeleteTransitGatewayRoute Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayRoute(DeleteTransitGatewayRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayRoute.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRoute">REST API Reference for DeleteTransitGatewayRoute Operation</seealso>
        public virtual DeleteTransitGatewayRouteResponse EndDeleteTransitGatewayRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayRouteTable

        /// <summary>
        /// Deletes the specified transit gateway route table. You must disassociate the route
        /// table from any transit gateway route tables before you can delete it.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayRouteTable service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRouteTable">REST API Reference for DeleteTransitGatewayRouteTable Operation</seealso>
        public virtual DeleteTransitGatewayRouteTableResponse DeleteTransitGatewayRouteTable(DeleteTransitGatewayRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayRouteTableResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRouteTable">REST API Reference for DeleteTransitGatewayRouteTable Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayRouteTable(DeleteTransitGatewayRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayRouteTable.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRouteTable">REST API Reference for DeleteTransitGatewayRouteTable Operation</seealso>
        public virtual DeleteTransitGatewayRouteTableResponse EndDeleteTransitGatewayRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayRouteTableAnnouncement

        /// <summary>
        /// Advertises to the transit gateway that a transit gateway route table is deleted.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayRouteTableAnnouncement service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayRouteTableAnnouncement service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRouteTableAnnouncement">REST API Reference for DeleteTransitGatewayRouteTableAnnouncement Operation</seealso>
        public virtual DeleteTransitGatewayRouteTableAnnouncementResponse DeleteTransitGatewayRouteTableAnnouncement(DeleteTransitGatewayRouteTableAnnouncementRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayRouteTableAnnouncementRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayRouteTableAnnouncementResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayRouteTableAnnouncementResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayRouteTableAnnouncement operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayRouteTableAnnouncement operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayRouteTableAnnouncement
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRouteTableAnnouncement">REST API Reference for DeleteTransitGatewayRouteTableAnnouncement Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayRouteTableAnnouncement(DeleteTransitGatewayRouteTableAnnouncementRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayRouteTableAnnouncementRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayRouteTableAnnouncementResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayRouteTableAnnouncement operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayRouteTableAnnouncement.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayRouteTableAnnouncementResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayRouteTableAnnouncement">REST API Reference for DeleteTransitGatewayRouteTableAnnouncement Operation</seealso>
        public virtual DeleteTransitGatewayRouteTableAnnouncementResponse EndDeleteTransitGatewayRouteTableAnnouncement(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayRouteTableAnnouncementResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteTransitGatewayVpcAttachment

        /// <summary>
        /// Deletes the specified VPC attachment.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayVpcAttachment service method.</param>
        /// 
        /// <returns>The response from the DeleteTransitGatewayVpcAttachment service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayVpcAttachment">REST API Reference for DeleteTransitGatewayVpcAttachment Operation</seealso>
        public virtual DeleteTransitGatewayVpcAttachmentResponse DeleteTransitGatewayVpcAttachment(DeleteTransitGatewayVpcAttachmentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return Invoke<DeleteTransitGatewayVpcAttachmentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteTransitGatewayVpcAttachment operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTransitGatewayVpcAttachment
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayVpcAttachment">REST API Reference for DeleteTransitGatewayVpcAttachment Operation</seealso>
        public virtual IAsyncResult BeginDeleteTransitGatewayVpcAttachment(DeleteTransitGatewayVpcAttachmentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteTransitGatewayVpcAttachment.</param>
        /// 
        /// <returns>Returns a  DeleteTransitGatewayVpcAttachmentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteTransitGatewayVpcAttachment">REST API Reference for DeleteTransitGatewayVpcAttachment Operation</seealso>
        public virtual DeleteTransitGatewayVpcAttachmentResponse EndDeleteTransitGatewayVpcAttachment(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteTransitGatewayVpcAttachmentResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVerifiedAccessEndpoint

        /// <summary>
        /// Delete an Amazon Web Services Verified Access endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedAccessEndpoint service method.</param>
        /// 
        /// <returns>The response from the DeleteVerifiedAccessEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessEndpoint">REST API Reference for DeleteVerifiedAccessEndpoint Operation</seealso>
        public virtual DeleteVerifiedAccessEndpointResponse DeleteVerifiedAccessEndpoint(DeleteVerifiedAccessEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVerifiedAccessEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVerifiedAccessEndpointResponseUnmarshaller.Instance;

            return Invoke<DeleteVerifiedAccessEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVerifiedAccessEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedAccessEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVerifiedAccessEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessEndpoint">REST API Reference for DeleteVerifiedAccessEndpoint Operation</seealso>
        public virtual IAsyncResult BeginDeleteVerifiedAccessEndpoint(DeleteVerifiedAccessEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVerifiedAccessEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVerifiedAccessEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVerifiedAccessEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVerifiedAccessEndpoint.</param>
        /// 
        /// <returns>Returns a  DeleteVerifiedAccessEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessEndpoint">REST API Reference for DeleteVerifiedAccessEndpoint Operation</seealso>
        public virtual DeleteVerifiedAccessEndpointResponse EndDeleteVerifiedAccessEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVerifiedAccessEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVerifiedAccessGroup

        /// <summary>
        /// Delete an Amazon Web Services Verified Access group.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedAccessGroup service method.</param>
        /// 
        /// <returns>The response from the DeleteVerifiedAccessGroup service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessGroup">REST API Reference for DeleteVerifiedAccessGroup Operation</seealso>
        public virtual DeleteVerifiedAccessGroupResponse DeleteVerifiedAccessGroup(DeleteVerifiedAccessGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVerifiedAccessGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVerifiedAccessGroupResponseUnmarshaller.Instance;

            return Invoke<DeleteVerifiedAccessGroupResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVerifiedAccessGroup operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedAccessGroup operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVerifiedAccessGroup
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessGroup">REST API Reference for DeleteVerifiedAccessGroup Operation</seealso>
        public virtual IAsyncResult BeginDeleteVerifiedAccessGroup(DeleteVerifiedAccessGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVerifiedAccessGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVerifiedAccessGroupResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVerifiedAccessGroup operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVerifiedAccessGroup.</param>
        /// 
        /// <returns>Returns a  DeleteVerifiedAccessGroupResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessGroup">REST API Reference for DeleteVerifiedAccessGroup Operation</seealso>
        public virtual DeleteVerifiedAccessGroupResponse EndDeleteVerifiedAccessGroup(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVerifiedAccessGroupResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVerifiedAccessInstance

        /// <summary>
        /// Delete an Amazon Web Services Verified Access instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedAccessInstance service method.</param>
        /// 
        /// <returns>The response from the DeleteVerifiedAccessInstance service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessInstance">REST API Reference for DeleteVerifiedAccessInstance Operation</seealso>
        public virtual DeleteVerifiedAccessInstanceResponse DeleteVerifiedAccessInstance(DeleteVerifiedAccessInstanceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVerifiedAccessInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVerifiedAccessInstanceResponseUnmarshaller.Instance;

            return Invoke<DeleteVerifiedAccessInstanceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVerifiedAccessInstance operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedAccessInstance operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVerifiedAccessInstance
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessInstance">REST API Reference for DeleteVerifiedAccessInstance Operation</seealso>
        public virtual IAsyncResult BeginDeleteVerifiedAccessInstance(DeleteVerifiedAccessInstanceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVerifiedAccessInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVerifiedAccessInstanceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVerifiedAccessInstance operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVerifiedAccessInstance.</param>
        /// 
        /// <returns>Returns a  DeleteVerifiedAccessInstanceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessInstance">REST API Reference for DeleteVerifiedAccessInstance Operation</seealso>
        public virtual DeleteVerifiedAccessInstanceResponse EndDeleteVerifiedAccessInstance(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVerifiedAccessInstanceResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVerifiedAccessTrustProvider

        /// <summary>
        /// Delete an Amazon Web Services Verified Access trust provider.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedAccessTrustProvider service method.</param>
        /// 
        /// <returns>The response from the DeleteVerifiedAccessTrustProvider service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessTrustProvider">REST API Reference for DeleteVerifiedAccessTrustProvider Operation</seealso>
        public virtual DeleteVerifiedAccessTrustProviderResponse DeleteVerifiedAccessTrustProvider(DeleteVerifiedAccessTrustProviderRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return Invoke<DeleteVerifiedAccessTrustProviderResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVerifiedAccessTrustProvider operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVerifiedAccessTrustProvider
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessTrustProvider">REST API Reference for DeleteVerifiedAccessTrustProvider Operation</seealso>
        public virtual IAsyncResult BeginDeleteVerifiedAccessTrustProvider(DeleteVerifiedAccessTrustProviderRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVerifiedAccessTrustProvider.</param>
        /// 
        /// <returns>Returns a  DeleteVerifiedAccessTrustProviderResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVerifiedAccessTrustProvider">REST API Reference for DeleteVerifiedAccessTrustProvider Operation</seealso>
        public virtual DeleteVerifiedAccessTrustProviderResponse EndDeleteVerifiedAccessTrustProvider(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVerifiedAccessTrustProviderResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVolume

        /// <summary>
        /// Deletes the specified EBS volume. The volume must be in the <code>available</code>
        /// state (not attached to an instance).
        /// 
        ///  
        /// <para>
        /// The volume can remain in the <code>deleting</code> state for several minutes.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-deleting-volume.html">Delete
        /// an Amazon EBS volume</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVolume service method.</param>
        /// 
        /// <returns>The response from the DeleteVolume service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVolume">REST API Reference for DeleteVolume Operation</seealso>
        public virtual DeleteVolumeResponse DeleteVolume(DeleteVolumeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVolumeResponseUnmarshaller.Instance;

            return Invoke<DeleteVolumeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVolume operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVolume operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVolume
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVolume">REST API Reference for DeleteVolume Operation</seealso>
        public virtual IAsyncResult BeginDeleteVolume(DeleteVolumeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVolumeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVolume operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVolume.</param>
        /// 
        /// <returns>Returns a  DeleteVolumeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVolume">REST API Reference for DeleteVolume Operation</seealso>
        public virtual DeleteVolumeResponse EndDeleteVolume(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVolumeResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVpc

        /// <summary>
        /// Deletes the specified VPC. You must detach or delete all gateways and resources that
        /// are associated with the VPC before you can delete it. For example, you must terminate
        /// all instances running in the VPC, delete all security groups associated with the VPC
        /// (except the default one), delete all route tables associated with the VPC (except
        /// the default one), and so on.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpc service method.</param>
        /// 
        /// <returns>The response from the DeleteVpc service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpc">REST API Reference for DeleteVpc Operation</seealso>
        public virtual DeleteVpcResponse DeleteVpc(DeleteVpcRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcResponseUnmarshaller.Instance;

            return Invoke<DeleteVpcResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVpc operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpc operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVpc
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpc">REST API Reference for DeleteVpc Operation</seealso>
        public virtual IAsyncResult BeginDeleteVpc(DeleteVpcRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVpc operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVpc.</param>
        /// 
        /// <returns>Returns a  DeleteVpcResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpc">REST API Reference for DeleteVpc Operation</seealso>
        public virtual DeleteVpcResponse EndDeleteVpc(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVpcResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVpcEndpointConnectionNotifications

        /// <summary>
        /// Deletes the specified VPC endpoint connection notifications.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpcEndpointConnectionNotifications service method.</param>
        /// 
        /// <returns>The response from the DeleteVpcEndpointConnectionNotifications service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpointConnectionNotifications">REST API Reference for DeleteVpcEndpointConnectionNotifications Operation</seealso>
        public virtual DeleteVpcEndpointConnectionNotificationsResponse DeleteVpcEndpointConnectionNotifications(DeleteVpcEndpointConnectionNotificationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcEndpointConnectionNotificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcEndpointConnectionNotificationsResponseUnmarshaller.Instance;

            return Invoke<DeleteVpcEndpointConnectionNotificationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVpcEndpointConnectionNotifications operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpcEndpointConnectionNotifications operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVpcEndpointConnectionNotifications
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpointConnectionNotifications">REST API Reference for DeleteVpcEndpointConnectionNotifications Operation</seealso>
        public virtual IAsyncResult BeginDeleteVpcEndpointConnectionNotifications(DeleteVpcEndpointConnectionNotificationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcEndpointConnectionNotificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcEndpointConnectionNotificationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVpcEndpointConnectionNotifications operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVpcEndpointConnectionNotifications.</param>
        /// 
        /// <returns>Returns a  DeleteVpcEndpointConnectionNotificationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpointConnectionNotifications">REST API Reference for DeleteVpcEndpointConnectionNotifications Operation</seealso>
        public virtual DeleteVpcEndpointConnectionNotificationsResponse EndDeleteVpcEndpointConnectionNotifications(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVpcEndpointConnectionNotificationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVpcEndpoints

        /// <summary>
        /// Deletes the specified VPC endpoints.
        /// 
        ///  
        /// <para>
        /// When you delete a gateway endpoint, we delete the endpoint routes in the route tables
        /// for the endpoint.
        /// </para>
        ///  
        /// <para>
        /// When you delete a Gateway Load Balancer endpoint, we delete its endpoint network interfaces.
        /// You can only delete Gateway Load Balancer endpoints when the routes that are associated
        /// with the endpoint are deleted.
        /// </para>
        ///  
        /// <para>
        /// When you delete an interface endpoint, we delete its endpoint network interfaces.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpcEndpoints service method.</param>
        /// 
        /// <returns>The response from the DeleteVpcEndpoints service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpoints">REST API Reference for DeleteVpcEndpoints Operation</seealso>
        public virtual DeleteVpcEndpointsResponse DeleteVpcEndpoints(DeleteVpcEndpointsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcEndpointsResponseUnmarshaller.Instance;

            return Invoke<DeleteVpcEndpointsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVpcEndpoints operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpcEndpoints operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVpcEndpoints
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpoints">REST API Reference for DeleteVpcEndpoints Operation</seealso>
        public virtual IAsyncResult BeginDeleteVpcEndpoints(DeleteVpcEndpointsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcEndpointsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVpcEndpoints operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVpcEndpoints.</param>
        /// 
        /// <returns>Returns a  DeleteVpcEndpointsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpoints">REST API Reference for DeleteVpcEndpoints Operation</seealso>
        public virtual DeleteVpcEndpointsResponse EndDeleteVpcEndpoints(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVpcEndpointsResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVpcEndpointServiceConfigurations

        /// <summary>
        /// Deletes the specified VPC endpoint service configurations. Before you can delete an
        /// endpoint service configuration, you must reject any <code>Available</code> or <code>PendingAcceptance</code>
        /// interface endpoint connections that are attached to the service.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpcEndpointServiceConfigurations service method.</param>
        /// 
        /// <returns>The response from the DeleteVpcEndpointServiceConfigurations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpointServiceConfigurations">REST API Reference for DeleteVpcEndpointServiceConfigurations Operation</seealso>
        public virtual DeleteVpcEndpointServiceConfigurationsResponse DeleteVpcEndpointServiceConfigurations(DeleteVpcEndpointServiceConfigurationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcEndpointServiceConfigurationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcEndpointServiceConfigurationsResponseUnmarshaller.Instance;

            return Invoke<DeleteVpcEndpointServiceConfigurationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVpcEndpointServiceConfigurations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpcEndpointServiceConfigurations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVpcEndpointServiceConfigurations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpointServiceConfigurations">REST API Reference for DeleteVpcEndpointServiceConfigurations Operation</seealso>
        public virtual IAsyncResult BeginDeleteVpcEndpointServiceConfigurations(DeleteVpcEndpointServiceConfigurationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcEndpointServiceConfigurationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcEndpointServiceConfigurationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVpcEndpointServiceConfigurations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVpcEndpointServiceConfigurations.</param>
        /// 
        /// <returns>Returns a  DeleteVpcEndpointServiceConfigurationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcEndpointServiceConfigurations">REST API Reference for DeleteVpcEndpointServiceConfigurations Operation</seealso>
        public virtual DeleteVpcEndpointServiceConfigurationsResponse EndDeleteVpcEndpointServiceConfigurations(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVpcEndpointServiceConfigurationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVpcPeeringConnection

        /// <summary>
        /// Deletes a VPC peering connection. Either the owner of the requester VPC or the owner
        /// of the accepter VPC can delete the VPC peering connection if it's in the <code>active</code>
        /// state. The owner of the requester VPC can delete a VPC peering connection in the <code>pending-acceptance</code>
        /// state. You cannot delete a VPC peering connection that's in the <code>failed</code>
        /// state.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpcPeeringConnection service method.</param>
        /// 
        /// <returns>The response from the DeleteVpcPeeringConnection service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcPeeringConnection">REST API Reference for DeleteVpcPeeringConnection Operation</seealso>
        public virtual DeleteVpcPeeringConnectionResponse DeleteVpcPeeringConnection(DeleteVpcPeeringConnectionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcPeeringConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcPeeringConnectionResponseUnmarshaller.Instance;

            return Invoke<DeleteVpcPeeringConnectionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVpcPeeringConnection operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpcPeeringConnection operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVpcPeeringConnection
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcPeeringConnection">REST API Reference for DeleteVpcPeeringConnection Operation</seealso>
        public virtual IAsyncResult BeginDeleteVpcPeeringConnection(DeleteVpcPeeringConnectionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpcPeeringConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpcPeeringConnectionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVpcPeeringConnection operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVpcPeeringConnection.</param>
        /// 
        /// <returns>Returns a  DeleteVpcPeeringConnectionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpcPeeringConnection">REST API Reference for DeleteVpcPeeringConnection Operation</seealso>
        public virtual DeleteVpcPeeringConnectionResponse EndDeleteVpcPeeringConnection(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVpcPeeringConnectionResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVpnConnection

        /// <summary>
        /// Deletes the specified VPN connection.
        /// 
        ///  
        /// <para>
        /// If you're deleting the VPC and its associated components, we recommend that you detach
        /// the virtual private gateway from the VPC and delete the VPC before deleting the VPN
        /// connection. If you believe that the tunnel credentials for your VPN connection have
        /// been compromised, you can delete the VPN connection and create a new one that has
        /// new keys, without needing to delete the VPC or virtual private gateway. If you create
        /// a new VPN connection, you must reconfigure the customer gateway device using the new
        /// configuration information returned with the new VPN connection ID.
        /// </para>
        ///  
        /// <para>
        /// For certificate-based authentication, delete all Certificate Manager (ACM) private
        /// certificates used for the Amazon Web Services-side tunnel endpoints for the VPN connection
        /// before deleting the VPN connection.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpnConnection service method.</param>
        /// 
        /// <returns>The response from the DeleteVpnConnection service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnection">REST API Reference for DeleteVpnConnection Operation</seealso>
        public virtual DeleteVpnConnectionResponse DeleteVpnConnection(DeleteVpnConnectionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpnConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpnConnectionResponseUnmarshaller.Instance;

            return Invoke<DeleteVpnConnectionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVpnConnection operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpnConnection operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVpnConnection
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnection">REST API Reference for DeleteVpnConnection Operation</seealso>
        public virtual IAsyncResult BeginDeleteVpnConnection(DeleteVpnConnectionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpnConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpnConnectionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVpnConnection operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVpnConnection.</param>
        /// 
        /// <returns>Returns a  DeleteVpnConnectionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnection">REST API Reference for DeleteVpnConnection Operation</seealso>
        public virtual DeleteVpnConnectionResponse EndDeleteVpnConnection(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVpnConnectionResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVpnConnectionRoute

        /// <summary>
        /// Deletes the specified static route associated with a VPN connection between an existing
        /// virtual private gateway and a VPN customer gateway. The static route allows traffic
        /// to be routed from the virtual private gateway to the VPN customer gateway.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpnConnectionRoute service method.</param>
        /// 
        /// <returns>The response from the DeleteVpnConnectionRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnectionRoute">REST API Reference for DeleteVpnConnectionRoute Operation</seealso>
        public virtual DeleteVpnConnectionRouteResponse DeleteVpnConnectionRoute(DeleteVpnConnectionRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpnConnectionRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpnConnectionRouteResponseUnmarshaller.Instance;

            return Invoke<DeleteVpnConnectionRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVpnConnectionRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpnConnectionRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVpnConnectionRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnectionRoute">REST API Reference for DeleteVpnConnectionRoute Operation</seealso>
        public virtual IAsyncResult BeginDeleteVpnConnectionRoute(DeleteVpnConnectionRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpnConnectionRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpnConnectionRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVpnConnectionRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVpnConnectionRoute.</param>
        /// 
        /// <returns>Returns a  DeleteVpnConnectionRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnConnectionRoute">REST API Reference for DeleteVpnConnectionRoute Operation</seealso>
        public virtual DeleteVpnConnectionRouteResponse EndDeleteVpnConnectionRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVpnConnectionRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  DeleteVpnGateway

        /// <summary>
        /// Deletes the specified virtual private gateway. You must first detach the virtual private
        /// gateway from the VPC. Note that you don't need to delete the virtual private gateway
        /// if you plan to delete and recreate the VPN connection between your VPC and your network.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpnGateway service method.</param>
        /// 
        /// <returns>The response from the DeleteVpnGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnGateway">REST API Reference for DeleteVpnGateway Operation</seealso>
        public virtual DeleteVpnGatewayResponse DeleteVpnGateway(DeleteVpnGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpnGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpnGatewayResponseUnmarshaller.Instance;

            return Invoke<DeleteVpnGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeleteVpnGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeleteVpnGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteVpnGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnGateway">REST API Reference for DeleteVpnGateway Operation</seealso>
        public virtual IAsyncResult BeginDeleteVpnGateway(DeleteVpnGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeleteVpnGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeleteVpnGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeleteVpnGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeleteVpnGateway.</param>
        /// 
        /// <returns>Returns a  DeleteVpnGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeleteVpnGateway">REST API Reference for DeleteVpnGateway Operation</seealso>
        public virtual DeleteVpnGatewayResponse EndDeleteVpnGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<DeleteVpnGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DeprovisionByoipCidr

        /// <summary>
        /// Releases the specified address range that you provisioned for use with your Amazon
        /// Web Services resources through bring your own IP addresses (BYOIP) and deletes the
        /// corresponding address pool.
        /// 
        ///  
        /// <para>
        /// Before you can release an address range, you must stop advertising it using <a>WithdrawByoipCidr</a>
        /// and you must not have any IP addresses allocated from its address range.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeprovisionByoipCidr service method.</param>
        /// 
        /// <returns>The response from the DeprovisionByoipCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionByoipCidr">REST API Reference for DeprovisionByoipCidr Operation</seealso>
        public virtual DeprovisionByoipCidrResponse DeprovisionByoipCidr(DeprovisionByoipCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeprovisionByoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeprovisionByoipCidrResponseUnmarshaller.Instance;

            return Invoke<DeprovisionByoipCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeprovisionByoipCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeprovisionByoipCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeprovisionByoipCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionByoipCidr">REST API Reference for DeprovisionByoipCidr Operation</seealso>
        public virtual IAsyncResult BeginDeprovisionByoipCidr(DeprovisionByoipCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeprovisionByoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeprovisionByoipCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeprovisionByoipCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeprovisionByoipCidr.</param>
        /// 
        /// <returns>Returns a  DeprovisionByoipCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionByoipCidr">REST API Reference for DeprovisionByoipCidr Operation</seealso>
        public virtual DeprovisionByoipCidrResponse EndDeprovisionByoipCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<DeprovisionByoipCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  DeprovisionIpamPoolCidr

        /// <summary>
        /// Deprovision a CIDR provisioned from an IPAM pool. If you deprovision a CIDR from a
        /// pool that has a source pool, the CIDR is recycled back into the source pool. For more
        /// information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/depro-pool-cidr-ipam.html">Deprovision
        /// pool CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeprovisionIpamPoolCidr service method.</param>
        /// 
        /// <returns>The response from the DeprovisionIpamPoolCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionIpamPoolCidr">REST API Reference for DeprovisionIpamPoolCidr Operation</seealso>
        public virtual DeprovisionIpamPoolCidrResponse DeprovisionIpamPoolCidr(DeprovisionIpamPoolCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeprovisionIpamPoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeprovisionIpamPoolCidrResponseUnmarshaller.Instance;

            return Invoke<DeprovisionIpamPoolCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeprovisionIpamPoolCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeprovisionIpamPoolCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeprovisionIpamPoolCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionIpamPoolCidr">REST API Reference for DeprovisionIpamPoolCidr Operation</seealso>
        public virtual IAsyncResult BeginDeprovisionIpamPoolCidr(DeprovisionIpamPoolCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeprovisionIpamPoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeprovisionIpamPoolCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeprovisionIpamPoolCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeprovisionIpamPoolCidr.</param>
        /// 
        /// <returns>Returns a  DeprovisionIpamPoolCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionIpamPoolCidr">REST API Reference for DeprovisionIpamPoolCidr Operation</seealso>
        public virtual DeprovisionIpamPoolCidrResponse EndDeprovisionIpamPoolCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<DeprovisionIpamPoolCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  DeprovisionPublicIpv4PoolCidr

        /// <summary>
        /// Deprovision a CIDR from a public IPv4 pool.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeprovisionPublicIpv4PoolCidr service method.</param>
        /// 
        /// <returns>The response from the DeprovisionPublicIpv4PoolCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionPublicIpv4PoolCidr">REST API Reference for DeprovisionPublicIpv4PoolCidr Operation</seealso>
        public virtual DeprovisionPublicIpv4PoolCidrResponse DeprovisionPublicIpv4PoolCidr(DeprovisionPublicIpv4PoolCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeprovisionPublicIpv4PoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeprovisionPublicIpv4PoolCidrResponseUnmarshaller.Instance;

            return Invoke<DeprovisionPublicIpv4PoolCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeprovisionPublicIpv4PoolCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeprovisionPublicIpv4PoolCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeprovisionPublicIpv4PoolCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionPublicIpv4PoolCidr">REST API Reference for DeprovisionPublicIpv4PoolCidr Operation</seealso>
        public virtual IAsyncResult BeginDeprovisionPublicIpv4PoolCidr(DeprovisionPublicIpv4PoolCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeprovisionPublicIpv4PoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeprovisionPublicIpv4PoolCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeprovisionPublicIpv4PoolCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeprovisionPublicIpv4PoolCidr.</param>
        /// 
        /// <returns>Returns a  DeprovisionPublicIpv4PoolCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeprovisionPublicIpv4PoolCidr">REST API Reference for DeprovisionPublicIpv4PoolCidr Operation</seealso>
        public virtual DeprovisionPublicIpv4PoolCidrResponse EndDeprovisionPublicIpv4PoolCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<DeprovisionPublicIpv4PoolCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  DeregisterImage

        /// <summary>
        /// Deregisters the specified AMI. After you deregister an AMI, it can't be used to launch
        /// new instances.
        /// 
        ///  
        /// <para>
        /// If you deregister an AMI that matches a Recycle Bin retention rule, the AMI is retained
        /// in the Recycle Bin for the specified retention period. For more information, see <a
        /// href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin.html">Recycle
        /// Bin</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// When you deregister an AMI, it doesn't affect any instances that you've already launched
        /// from the AMI. You'll continue to incur usage costs for those instances until you terminate
        /// them.
        /// </para>
        ///  
        /// <para>
        /// When you deregister an Amazon EBS-backed AMI, it doesn't affect the snapshot that
        /// was created for the root volume of the instance during the AMI creation process. When
        /// you deregister an instance store-backed AMI, it doesn't affect the files that you
        /// uploaded to Amazon S3 when you created the AMI.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeregisterImage service method.</param>
        /// 
        /// <returns>The response from the DeregisterImage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterImage">REST API Reference for DeregisterImage Operation</seealso>
        public virtual DeregisterImageResponse DeregisterImage(DeregisterImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterImageResponseUnmarshaller.Instance;

            return Invoke<DeregisterImageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeregisterImage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeregisterImage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterImage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterImage">REST API Reference for DeregisterImage Operation</seealso>
        public virtual IAsyncResult BeginDeregisterImage(DeregisterImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterImageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeregisterImage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeregisterImage.</param>
        /// 
        /// <returns>Returns a  DeregisterImageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterImage">REST API Reference for DeregisterImage Operation</seealso>
        public virtual DeregisterImageResponse EndDeregisterImage(IAsyncResult asyncResult)
        {
            return EndInvoke<DeregisterImageResponse>(asyncResult);
        }

        #endregion
        
        #region  DeregisterInstanceEventNotificationAttributes

        /// <summary>
        /// Deregisters tag keys to prevent tags that have the specified tag keys from being included
        /// in scheduled event notifications for resources in the Region.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeregisterInstanceEventNotificationAttributes service method.</param>
        /// 
        /// <returns>The response from the DeregisterInstanceEventNotificationAttributes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterInstanceEventNotificationAttributes">REST API Reference for DeregisterInstanceEventNotificationAttributes Operation</seealso>
        public virtual DeregisterInstanceEventNotificationAttributesResponse DeregisterInstanceEventNotificationAttributes(DeregisterInstanceEventNotificationAttributesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterInstanceEventNotificationAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterInstanceEventNotificationAttributesResponseUnmarshaller.Instance;

            return Invoke<DeregisterInstanceEventNotificationAttributesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeregisterInstanceEventNotificationAttributes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeregisterInstanceEventNotificationAttributes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterInstanceEventNotificationAttributes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterInstanceEventNotificationAttributes">REST API Reference for DeregisterInstanceEventNotificationAttributes Operation</seealso>
        public virtual IAsyncResult BeginDeregisterInstanceEventNotificationAttributes(DeregisterInstanceEventNotificationAttributesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterInstanceEventNotificationAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterInstanceEventNotificationAttributesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeregisterInstanceEventNotificationAttributes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeregisterInstanceEventNotificationAttributes.</param>
        /// 
        /// <returns>Returns a  DeregisterInstanceEventNotificationAttributesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterInstanceEventNotificationAttributes">REST API Reference for DeregisterInstanceEventNotificationAttributes Operation</seealso>
        public virtual DeregisterInstanceEventNotificationAttributesResponse EndDeregisterInstanceEventNotificationAttributes(IAsyncResult asyncResult)
        {
            return EndInvoke<DeregisterInstanceEventNotificationAttributesResponse>(asyncResult);
        }

        #endregion
        
        #region  DeregisterTransitGatewayMulticastGroupMembers

        /// <summary>
        /// Deregisters the specified members (network interfaces) from the transit gateway multicast
        /// group.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeregisterTransitGatewayMulticastGroupMembers service method.</param>
        /// 
        /// <returns>The response from the DeregisterTransitGatewayMulticastGroupMembers service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterTransitGatewayMulticastGroupMembers">REST API Reference for DeregisterTransitGatewayMulticastGroupMembers Operation</seealso>
        public virtual DeregisterTransitGatewayMulticastGroupMembersResponse DeregisterTransitGatewayMulticastGroupMembers(DeregisterTransitGatewayMulticastGroupMembersRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterTransitGatewayMulticastGroupMembersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterTransitGatewayMulticastGroupMembersResponseUnmarshaller.Instance;

            return Invoke<DeregisterTransitGatewayMulticastGroupMembersResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeregisterTransitGatewayMulticastGroupMembers operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeregisterTransitGatewayMulticastGroupMembers operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterTransitGatewayMulticastGroupMembers
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterTransitGatewayMulticastGroupMembers">REST API Reference for DeregisterTransitGatewayMulticastGroupMembers Operation</seealso>
        public virtual IAsyncResult BeginDeregisterTransitGatewayMulticastGroupMembers(DeregisterTransitGatewayMulticastGroupMembersRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterTransitGatewayMulticastGroupMembersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterTransitGatewayMulticastGroupMembersResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeregisterTransitGatewayMulticastGroupMembers operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeregisterTransitGatewayMulticastGroupMembers.</param>
        /// 
        /// <returns>Returns a  DeregisterTransitGatewayMulticastGroupMembersResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterTransitGatewayMulticastGroupMembers">REST API Reference for DeregisterTransitGatewayMulticastGroupMembers Operation</seealso>
        public virtual DeregisterTransitGatewayMulticastGroupMembersResponse EndDeregisterTransitGatewayMulticastGroupMembers(IAsyncResult asyncResult)
        {
            return EndInvoke<DeregisterTransitGatewayMulticastGroupMembersResponse>(asyncResult);
        }

        #endregion
        
        #region  DeregisterTransitGatewayMulticastGroupSources

        /// <summary>
        /// Deregisters the specified sources (network interfaces) from the transit gateway multicast
        /// group.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DeregisterTransitGatewayMulticastGroupSources service method.</param>
        /// 
        /// <returns>The response from the DeregisterTransitGatewayMulticastGroupSources service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterTransitGatewayMulticastGroupSources">REST API Reference for DeregisterTransitGatewayMulticastGroupSources Operation</seealso>
        public virtual DeregisterTransitGatewayMulticastGroupSourcesResponse DeregisterTransitGatewayMulticastGroupSources(DeregisterTransitGatewayMulticastGroupSourcesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterTransitGatewayMulticastGroupSourcesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterTransitGatewayMulticastGroupSourcesResponseUnmarshaller.Instance;

            return Invoke<DeregisterTransitGatewayMulticastGroupSourcesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DeregisterTransitGatewayMulticastGroupSources operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DeregisterTransitGatewayMulticastGroupSources operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterTransitGatewayMulticastGroupSources
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterTransitGatewayMulticastGroupSources">REST API Reference for DeregisterTransitGatewayMulticastGroupSources Operation</seealso>
        public virtual IAsyncResult BeginDeregisterTransitGatewayMulticastGroupSources(DeregisterTransitGatewayMulticastGroupSourcesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DeregisterTransitGatewayMulticastGroupSourcesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DeregisterTransitGatewayMulticastGroupSourcesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DeregisterTransitGatewayMulticastGroupSources operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDeregisterTransitGatewayMulticastGroupSources.</param>
        /// 
        /// <returns>Returns a  DeregisterTransitGatewayMulticastGroupSourcesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DeregisterTransitGatewayMulticastGroupSources">REST API Reference for DeregisterTransitGatewayMulticastGroupSources Operation</seealso>
        public virtual DeregisterTransitGatewayMulticastGroupSourcesResponse EndDeregisterTransitGatewayMulticastGroupSources(IAsyncResult asyncResult)
        {
            return EndInvoke<DeregisterTransitGatewayMulticastGroupSourcesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeAccountAttributes

        /// <summary>
        /// Describes attributes of your Amazon Web Services account. The following are the supported
        /// account attributes:
        /// 
        ///  <ul> <li> 
        /// <para>
        ///  <code>default-vpc</code>: The ID of the default VPC for your account, or <code>none</code>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>max-instances</code>: This attribute is no longer supported. The returned value
        /// does not reflect your actual vCPU limit for running On-Demand Instances. For more
        /// information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-on-demand-instances.html#ec2-on-demand-instances-limits">On-Demand
        /// Instance Limits</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>max-elastic-ips</code>: The maximum number of Elastic IP addresses that you
        /// can allocate.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>supported-platforms</code>: This attribute is deprecated.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>vpc-max-elastic-ips</code>: The maximum number of Elastic IP addresses that
        /// you can allocate.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>vpc-max-security-groups-per-interface</code>: The maximum number of security
        /// groups that you can assign to a network interface.
        /// </para>
        ///  </li> </ul>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeAccountAttributes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAccountAttributes">REST API Reference for DescribeAccountAttributes Operation</seealso>
        public virtual DescribeAccountAttributesResponse DescribeAccountAttributes()
        {
            return DescribeAccountAttributes(new DescribeAccountAttributesRequest());
        }

        /// <summary>
        /// Describes attributes of your Amazon Web Services account. The following are the supported
        /// account attributes:
        /// 
        ///  <ul> <li> 
        /// <para>
        ///  <code>default-vpc</code>: The ID of the default VPC for your account, or <code>none</code>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>max-instances</code>: This attribute is no longer supported. The returned value
        /// does not reflect your actual vCPU limit for running On-Demand Instances. For more
        /// information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-on-demand-instances.html#ec2-on-demand-instances-limits">On-Demand
        /// Instance Limits</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>max-elastic-ips</code>: The maximum number of Elastic IP addresses that you
        /// can allocate.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>supported-platforms</code>: This attribute is deprecated.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>vpc-max-elastic-ips</code>: The maximum number of Elastic IP addresses that
        /// you can allocate.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <code>vpc-max-security-groups-per-interface</code>: The maximum number of security
        /// groups that you can assign to a network interface.
        /// </para>
        ///  </li> </ul>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeAccountAttributes service method.</param>
        /// 
        /// <returns>The response from the DescribeAccountAttributes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAccountAttributes">REST API Reference for DescribeAccountAttributes Operation</seealso>
        public virtual DescribeAccountAttributesResponse DescribeAccountAttributes(DescribeAccountAttributesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAccountAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAccountAttributesResponseUnmarshaller.Instance;

            return Invoke<DescribeAccountAttributesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeAccountAttributes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeAccountAttributes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAccountAttributes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAccountAttributes">REST API Reference for DescribeAccountAttributes Operation</seealso>
        public virtual IAsyncResult BeginDescribeAccountAttributes(DescribeAccountAttributesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAccountAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAccountAttributesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeAccountAttributes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeAccountAttributes.</param>
        /// 
        /// <returns>Returns a  DescribeAccountAttributesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAccountAttributes">REST API Reference for DescribeAccountAttributes Operation</seealso>
        public virtual DescribeAccountAttributesResponse EndDescribeAccountAttributes(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeAccountAttributesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeAddresses

        /// <summary>
        /// Describes the specified Elastic IP addresses or all of your Elastic IP addresses.
        /// </summary>
        /// 
        /// <returns>The response from the DescribeAddresses service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddresses">REST API Reference for DescribeAddresses Operation</seealso>
        public virtual DescribeAddressesResponse DescribeAddresses()
        {
            return DescribeAddresses(new DescribeAddressesRequest());
        }

        /// <summary>
        /// Describes the specified Elastic IP addresses or all of your Elastic IP addresses.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeAddresses service method.</param>
        /// 
        /// <returns>The response from the DescribeAddresses service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddresses">REST API Reference for DescribeAddresses Operation</seealso>
        public virtual DescribeAddressesResponse DescribeAddresses(DescribeAddressesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAddressesResponseUnmarshaller.Instance;

            return Invoke<DescribeAddressesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeAddresses operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeAddresses operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAddresses
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddresses">REST API Reference for DescribeAddresses Operation</seealso>
        public virtual IAsyncResult BeginDescribeAddresses(DescribeAddressesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAddressesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeAddresses operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeAddresses.</param>
        /// 
        /// <returns>Returns a  DescribeAddressesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddresses">REST API Reference for DescribeAddresses Operation</seealso>
        public virtual DescribeAddressesResponse EndDescribeAddresses(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeAddressesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeAddressesAttribute

        /// <summary>
        /// Describes the attributes of the specified Elastic IP addresses. For requirements,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html#Using_Elastic_Addressing_Reverse_DNS">Using
        /// reverse DNS for email applications</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeAddressesAttribute service method.</param>
        /// 
        /// <returns>The response from the DescribeAddressesAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddressesAttribute">REST API Reference for DescribeAddressesAttribute Operation</seealso>
        public virtual DescribeAddressesAttributeResponse DescribeAddressesAttribute(DescribeAddressesAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAddressesAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAddressesAttributeResponseUnmarshaller.Instance;

            return Invoke<DescribeAddressesAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeAddressesAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeAddressesAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAddressesAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddressesAttribute">REST API Reference for DescribeAddressesAttribute Operation</seealso>
        public virtual IAsyncResult BeginDescribeAddressesAttribute(DescribeAddressesAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAddressesAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAddressesAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeAddressesAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeAddressesAttribute.</param>
        /// 
        /// <returns>Returns a  DescribeAddressesAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddressesAttribute">REST API Reference for DescribeAddressesAttribute Operation</seealso>
        public virtual DescribeAddressesAttributeResponse EndDescribeAddressesAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeAddressesAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeAddressTransfers

        /// <summary>
        /// Describes an Elastic IP address transfer. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro">Transfer
        /// Elastic IP addresses</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.
        /// 
        ///  
        /// <para>
        /// When you transfer an Elastic IP address, there is a two-step handshake between the
        /// source and transfer Amazon Web Services accounts. When the source account starts the
        /// transfer, the transfer account has seven days to accept the Elastic IP address transfer.
        /// During those seven days, the source account can view the pending transfer by using
        /// this action. After seven days, the transfer expires and ownership of the Elastic IP
        /// address returns to the source account. Accepted transfers are visible to the source
        /// account for three days after the transfers have been accepted.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeAddressTransfers service method.</param>
        /// 
        /// <returns>The response from the DescribeAddressTransfers service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddressTransfers">REST API Reference for DescribeAddressTransfers Operation</seealso>
        public virtual DescribeAddressTransfersResponse DescribeAddressTransfers(DescribeAddressTransfersRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAddressTransfersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAddressTransfersResponseUnmarshaller.Instance;

            return Invoke<DescribeAddressTransfersResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeAddressTransfers operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeAddressTransfers operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAddressTransfers
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddressTransfers">REST API Reference for DescribeAddressTransfers Operation</seealso>
        public virtual IAsyncResult BeginDescribeAddressTransfers(DescribeAddressTransfersRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAddressTransfersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAddressTransfersResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeAddressTransfers operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeAddressTransfers.</param>
        /// 
        /// <returns>Returns a  DescribeAddressTransfersResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAddressTransfers">REST API Reference for DescribeAddressTransfers Operation</seealso>
        public virtual DescribeAddressTransfersResponse EndDescribeAddressTransfers(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeAddressTransfersResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeAggregateIdFormat

        /// <summary>
        /// Describes the longer ID format settings for all resource types in a specific Region.
        /// This request is useful for performing a quick audit to determine whether a specific
        /// Region is fully opted in for longer IDs (17-character IDs).
        /// 
        ///  
        /// <para>
        /// This request only returns information about resource types that support longer IDs.
        /// </para>
        ///  
        /// <para>
        /// The following resource types support longer IDs: <code>bundle</code> | <code>conversion-task</code>
        /// | <code>customer-gateway</code> | <code>dhcp-options</code> | <code>elastic-ip-allocation</code>
        /// | <code>elastic-ip-association</code> | <code>export-task</code> | <code>flow-log</code>
        /// | <code>image</code> | <code>import-task</code> | <code>instance</code> | <code>internet-gateway</code>
        /// | <code>network-acl</code> | <code>network-acl-association</code> | <code>network-interface</code>
        /// | <code>network-interface-attachment</code> | <code>prefix-list</code> | <code>reservation</code>
        /// | <code>route-table</code> | <code>route-table-association</code> | <code>security-group</code>
        /// | <code>snapshot</code> | <code>subnet</code> | <code>subnet-cidr-block-association</code>
        /// | <code>volume</code> | <code>vpc</code> | <code>vpc-cidr-block-association</code>
        /// | <code>vpc-endpoint</code> | <code>vpc-peering-connection</code> | <code>vpn-connection</code>
        /// | <code>vpn-gateway</code>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeAggregateIdFormat service method.</param>
        /// 
        /// <returns>The response from the DescribeAggregateIdFormat service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAggregateIdFormat">REST API Reference for DescribeAggregateIdFormat Operation</seealso>
        public virtual DescribeAggregateIdFormatResponse DescribeAggregateIdFormat(DescribeAggregateIdFormatRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAggregateIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAggregateIdFormatResponseUnmarshaller.Instance;

            return Invoke<DescribeAggregateIdFormatResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeAggregateIdFormat operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeAggregateIdFormat operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAggregateIdFormat
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAggregateIdFormat">REST API Reference for DescribeAggregateIdFormat Operation</seealso>
        public virtual IAsyncResult BeginDescribeAggregateIdFormat(DescribeAggregateIdFormatRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAggregateIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAggregateIdFormatResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeAggregateIdFormat operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeAggregateIdFormat.</param>
        /// 
        /// <returns>Returns a  DescribeAggregateIdFormatResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAggregateIdFormat">REST API Reference for DescribeAggregateIdFormat Operation</seealso>
        public virtual DescribeAggregateIdFormatResponse EndDescribeAggregateIdFormat(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeAggregateIdFormatResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeAvailabilityZones

        /// <summary>
        /// Describes the Availability Zones, Local Zones, and Wavelength Zones that are available
        /// to you. If there is an event impacting a zone, you can use this request to view the
        /// state and any provided messages for that zone.
        /// 
        ///  
        /// <para>
        /// For more information about Availability Zones, Local Zones, and Wavelength Zones,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html">Regions
        /// and zones</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeAvailabilityZones service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAvailabilityZones">REST API Reference for DescribeAvailabilityZones Operation</seealso>
        public virtual DescribeAvailabilityZonesResponse DescribeAvailabilityZones()
        {
            return DescribeAvailabilityZones(new DescribeAvailabilityZonesRequest());
        }

        /// <summary>
        /// Describes the Availability Zones, Local Zones, and Wavelength Zones that are available
        /// to you. If there is an event impacting a zone, you can use this request to view the
        /// state and any provided messages for that zone.
        /// 
        ///  
        /// <para>
        /// For more information about Availability Zones, Local Zones, and Wavelength Zones,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html">Regions
        /// and zones</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeAvailabilityZones service method.</param>
        /// 
        /// <returns>The response from the DescribeAvailabilityZones service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAvailabilityZones">REST API Reference for DescribeAvailabilityZones Operation</seealso>
        public virtual DescribeAvailabilityZonesResponse DescribeAvailabilityZones(DescribeAvailabilityZonesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAvailabilityZonesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAvailabilityZonesResponseUnmarshaller.Instance;

            return Invoke<DescribeAvailabilityZonesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeAvailabilityZones operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeAvailabilityZones operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAvailabilityZones
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAvailabilityZones">REST API Reference for DescribeAvailabilityZones Operation</seealso>
        public virtual IAsyncResult BeginDescribeAvailabilityZones(DescribeAvailabilityZonesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAvailabilityZonesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAvailabilityZonesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeAvailabilityZones operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeAvailabilityZones.</param>
        /// 
        /// <returns>Returns a  DescribeAvailabilityZonesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAvailabilityZones">REST API Reference for DescribeAvailabilityZones Operation</seealso>
        public virtual DescribeAvailabilityZonesResponse EndDescribeAvailabilityZones(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeAvailabilityZonesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeAwsNetworkPerformanceMetricSubscriptions

        /// <summary>
        /// Describes the current Infrastructure Performance metric subscriptions.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeAwsNetworkPerformanceMetricSubscriptions service method.</param>
        /// 
        /// <returns>The response from the DescribeAwsNetworkPerformanceMetricSubscriptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAwsNetworkPerformanceMetricSubscriptions">REST API Reference for DescribeAwsNetworkPerformanceMetricSubscriptions Operation</seealso>
        public virtual DescribeAwsNetworkPerformanceMetricSubscriptionsResponse DescribeAwsNetworkPerformanceMetricSubscriptions(DescribeAwsNetworkPerformanceMetricSubscriptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAwsNetworkPerformanceMetricSubscriptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAwsNetworkPerformanceMetricSubscriptionsResponseUnmarshaller.Instance;

            return Invoke<DescribeAwsNetworkPerformanceMetricSubscriptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeAwsNetworkPerformanceMetricSubscriptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeAwsNetworkPerformanceMetricSubscriptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeAwsNetworkPerformanceMetricSubscriptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAwsNetworkPerformanceMetricSubscriptions">REST API Reference for DescribeAwsNetworkPerformanceMetricSubscriptions Operation</seealso>
        public virtual IAsyncResult BeginDescribeAwsNetworkPerformanceMetricSubscriptions(DescribeAwsNetworkPerformanceMetricSubscriptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeAwsNetworkPerformanceMetricSubscriptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeAwsNetworkPerformanceMetricSubscriptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeAwsNetworkPerformanceMetricSubscriptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeAwsNetworkPerformanceMetricSubscriptions.</param>
        /// 
        /// <returns>Returns a  DescribeAwsNetworkPerformanceMetricSubscriptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeAwsNetworkPerformanceMetricSubscriptions">REST API Reference for DescribeAwsNetworkPerformanceMetricSubscriptions Operation</seealso>
        public virtual DescribeAwsNetworkPerformanceMetricSubscriptionsResponse EndDescribeAwsNetworkPerformanceMetricSubscriptions(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeAwsNetworkPerformanceMetricSubscriptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeBundleTasks

        /// <summary>
        /// Describes the specified bundle tasks or all of your bundle tasks.
        /// 
        ///  <note> 
        /// <para>
        /// Completed bundle tasks are listed for only a limited time. If your bundle task is
        /// no longer in the list, you can still register an AMI from it. Just use <code>RegisterImage</code>
        /// with the Amazon S3 bucket name and image manifest name you provided to the bundle
        /// task.
        /// </para>
        ///  </note>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeBundleTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeBundleTasks">REST API Reference for DescribeBundleTasks Operation</seealso>
        public virtual DescribeBundleTasksResponse DescribeBundleTasks()
        {
            return DescribeBundleTasks(new DescribeBundleTasksRequest());
        }

        /// <summary>
        /// Describes the specified bundle tasks or all of your bundle tasks.
        /// 
        ///  <note> 
        /// <para>
        /// Completed bundle tasks are listed for only a limited time. If your bundle task is
        /// no longer in the list, you can still register an AMI from it. Just use <code>RegisterImage</code>
        /// with the Amazon S3 bucket name and image manifest name you provided to the bundle
        /// task.
        /// </para>
        ///  </note>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeBundleTasks service method.</param>
        /// 
        /// <returns>The response from the DescribeBundleTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeBundleTasks">REST API Reference for DescribeBundleTasks Operation</seealso>
        public virtual DescribeBundleTasksResponse DescribeBundleTasks(DescribeBundleTasksRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeBundleTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeBundleTasksResponseUnmarshaller.Instance;

            return Invoke<DescribeBundleTasksResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeBundleTasks operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeBundleTasks operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeBundleTasks
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeBundleTasks">REST API Reference for DescribeBundleTasks Operation</seealso>
        public virtual IAsyncResult BeginDescribeBundleTasks(DescribeBundleTasksRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeBundleTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeBundleTasksResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeBundleTasks operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeBundleTasks.</param>
        /// 
        /// <returns>Returns a  DescribeBundleTasksResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeBundleTasks">REST API Reference for DescribeBundleTasks Operation</seealso>
        public virtual DescribeBundleTasksResponse EndDescribeBundleTasks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeBundleTasksResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeByoipCidrs

        /// <summary>
        /// Describes the IP address ranges that were specified in calls to <a>ProvisionByoipCidr</a>.
        /// 
        ///  
        /// <para>
        /// To describe the address pools that were created when you provisioned the address ranges,
        /// use <a>DescribePublicIpv4Pools</a> or <a>DescribeIpv6Pools</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeByoipCidrs service method.</param>
        /// 
        /// <returns>The response from the DescribeByoipCidrs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeByoipCidrs">REST API Reference for DescribeByoipCidrs Operation</seealso>
        public virtual DescribeByoipCidrsResponse DescribeByoipCidrs(DescribeByoipCidrsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeByoipCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeByoipCidrsResponseUnmarshaller.Instance;

            return Invoke<DescribeByoipCidrsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeByoipCidrs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeByoipCidrs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeByoipCidrs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeByoipCidrs">REST API Reference for DescribeByoipCidrs Operation</seealso>
        public virtual IAsyncResult BeginDescribeByoipCidrs(DescribeByoipCidrsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeByoipCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeByoipCidrsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeByoipCidrs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeByoipCidrs.</param>
        /// 
        /// <returns>Returns a  DescribeByoipCidrsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeByoipCidrs">REST API Reference for DescribeByoipCidrs Operation</seealso>
        public virtual DescribeByoipCidrsResponse EndDescribeByoipCidrs(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeByoipCidrsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeCapacityReservationFleets

        /// <summary>
        /// Describes one or more Capacity Reservation Fleets.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeCapacityReservationFleets service method.</param>
        /// 
        /// <returns>The response from the DescribeCapacityReservationFleets service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservationFleets">REST API Reference for DescribeCapacityReservationFleets Operation</seealso>
        public virtual DescribeCapacityReservationFleetsResponse DescribeCapacityReservationFleets(DescribeCapacityReservationFleetsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCapacityReservationFleetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCapacityReservationFleetsResponseUnmarshaller.Instance;

            return Invoke<DescribeCapacityReservationFleetsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeCapacityReservationFleets operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeCapacityReservationFleets operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeCapacityReservationFleets
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservationFleets">REST API Reference for DescribeCapacityReservationFleets Operation</seealso>
        public virtual IAsyncResult BeginDescribeCapacityReservationFleets(DescribeCapacityReservationFleetsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCapacityReservationFleetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCapacityReservationFleetsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeCapacityReservationFleets operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeCapacityReservationFleets.</param>
        /// 
        /// <returns>Returns a  DescribeCapacityReservationFleetsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservationFleets">REST API Reference for DescribeCapacityReservationFleets Operation</seealso>
        public virtual DescribeCapacityReservationFleetsResponse EndDescribeCapacityReservationFleets(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeCapacityReservationFleetsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeCapacityReservations

        /// <summary>
        /// Describes one or more of your Capacity Reservations. The results describe only the
        /// Capacity Reservations in the Amazon Web Services Region that you're currently using.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeCapacityReservations service method.</param>
        /// 
        /// <returns>The response from the DescribeCapacityReservations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservations">REST API Reference for DescribeCapacityReservations Operation</seealso>
        public virtual DescribeCapacityReservationsResponse DescribeCapacityReservations(DescribeCapacityReservationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCapacityReservationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCapacityReservationsResponseUnmarshaller.Instance;

            return Invoke<DescribeCapacityReservationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeCapacityReservations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeCapacityReservations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeCapacityReservations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservations">REST API Reference for DescribeCapacityReservations Operation</seealso>
        public virtual IAsyncResult BeginDescribeCapacityReservations(DescribeCapacityReservationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCapacityReservationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCapacityReservationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeCapacityReservations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeCapacityReservations.</param>
        /// 
        /// <returns>Returns a  DescribeCapacityReservationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCapacityReservations">REST API Reference for DescribeCapacityReservations Operation</seealso>
        public virtual DescribeCapacityReservationsResponse EndDescribeCapacityReservations(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeCapacityReservationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeCarrierGateways

        /// <summary>
        /// Describes one or more of your carrier gateways.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeCarrierGateways service method.</param>
        /// 
        /// <returns>The response from the DescribeCarrierGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCarrierGateways">REST API Reference for DescribeCarrierGateways Operation</seealso>
        public virtual DescribeCarrierGatewaysResponse DescribeCarrierGateways(DescribeCarrierGatewaysRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCarrierGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCarrierGatewaysResponseUnmarshaller.Instance;

            return Invoke<DescribeCarrierGatewaysResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeCarrierGateways operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeCarrierGateways operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeCarrierGateways
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCarrierGateways">REST API Reference for DescribeCarrierGateways Operation</seealso>
        public virtual IAsyncResult BeginDescribeCarrierGateways(DescribeCarrierGatewaysRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCarrierGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCarrierGatewaysResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeCarrierGateways operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeCarrierGateways.</param>
        /// 
        /// <returns>Returns a  DescribeCarrierGatewaysResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCarrierGateways">REST API Reference for DescribeCarrierGateways Operation</seealso>
        public virtual DescribeCarrierGatewaysResponse EndDescribeCarrierGateways(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeCarrierGatewaysResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeClassicLinkInstances

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Describes one or more of your linked EC2-Classic instances. This request only returns
        /// information about EC2-Classic instances linked to a VPC through ClassicLink. You cannot
        /// use this request to return information about other instances.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeClassicLinkInstances service method.</param>
        /// 
        /// <returns>The response from the DescribeClassicLinkInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClassicLinkInstances">REST API Reference for DescribeClassicLinkInstances Operation</seealso>
        public virtual DescribeClassicLinkInstancesResponse DescribeClassicLinkInstances(DescribeClassicLinkInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClassicLinkInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClassicLinkInstancesResponseUnmarshaller.Instance;

            return Invoke<DescribeClassicLinkInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeClassicLinkInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeClassicLinkInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClassicLinkInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClassicLinkInstances">REST API Reference for DescribeClassicLinkInstances Operation</seealso>
        public virtual IAsyncResult BeginDescribeClassicLinkInstances(DescribeClassicLinkInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClassicLinkInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClassicLinkInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeClassicLinkInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeClassicLinkInstances.</param>
        /// 
        /// <returns>Returns a  DescribeClassicLinkInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClassicLinkInstances">REST API Reference for DescribeClassicLinkInstances Operation</seealso>
        public virtual DescribeClassicLinkInstancesResponse EndDescribeClassicLinkInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeClassicLinkInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeClientVpnAuthorizationRules

        /// <summary>
        /// Describes the authorization rules for a specified Client VPN endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnAuthorizationRules service method.</param>
        /// 
        /// <returns>The response from the DescribeClientVpnAuthorizationRules service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnAuthorizationRules">REST API Reference for DescribeClientVpnAuthorizationRules Operation</seealso>
        public virtual DescribeClientVpnAuthorizationRulesResponse DescribeClientVpnAuthorizationRules(DescribeClientVpnAuthorizationRulesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnAuthorizationRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnAuthorizationRulesResponseUnmarshaller.Instance;

            return Invoke<DescribeClientVpnAuthorizationRulesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeClientVpnAuthorizationRules operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnAuthorizationRules operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClientVpnAuthorizationRules
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnAuthorizationRules">REST API Reference for DescribeClientVpnAuthorizationRules Operation</seealso>
        public virtual IAsyncResult BeginDescribeClientVpnAuthorizationRules(DescribeClientVpnAuthorizationRulesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnAuthorizationRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnAuthorizationRulesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeClientVpnAuthorizationRules operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeClientVpnAuthorizationRules.</param>
        /// 
        /// <returns>Returns a  DescribeClientVpnAuthorizationRulesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnAuthorizationRules">REST API Reference for DescribeClientVpnAuthorizationRules Operation</seealso>
        public virtual DescribeClientVpnAuthorizationRulesResponse EndDescribeClientVpnAuthorizationRules(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeClientVpnAuthorizationRulesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeClientVpnConnections

        /// <summary>
        /// Describes active client connections and connections that have been terminated within
        /// the last 60 minutes for the specified Client VPN endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnConnections service method.</param>
        /// 
        /// <returns>The response from the DescribeClientVpnConnections service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnConnections">REST API Reference for DescribeClientVpnConnections Operation</seealso>
        public virtual DescribeClientVpnConnectionsResponse DescribeClientVpnConnections(DescribeClientVpnConnectionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnConnectionsResponseUnmarshaller.Instance;

            return Invoke<DescribeClientVpnConnectionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeClientVpnConnections operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnConnections operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClientVpnConnections
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnConnections">REST API Reference for DescribeClientVpnConnections Operation</seealso>
        public virtual IAsyncResult BeginDescribeClientVpnConnections(DescribeClientVpnConnectionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnConnectionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeClientVpnConnections operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeClientVpnConnections.</param>
        /// 
        /// <returns>Returns a  DescribeClientVpnConnectionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnConnections">REST API Reference for DescribeClientVpnConnections Operation</seealso>
        public virtual DescribeClientVpnConnectionsResponse EndDescribeClientVpnConnections(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeClientVpnConnectionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeClientVpnEndpoints

        /// <summary>
        /// Describes one or more Client VPN endpoints in the account.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnEndpoints service method.</param>
        /// 
        /// <returns>The response from the DescribeClientVpnEndpoints service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnEndpoints">REST API Reference for DescribeClientVpnEndpoints Operation</seealso>
        public virtual DescribeClientVpnEndpointsResponse DescribeClientVpnEndpoints(DescribeClientVpnEndpointsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnEndpointsResponseUnmarshaller.Instance;

            return Invoke<DescribeClientVpnEndpointsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeClientVpnEndpoints operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnEndpoints operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClientVpnEndpoints
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnEndpoints">REST API Reference for DescribeClientVpnEndpoints Operation</seealso>
        public virtual IAsyncResult BeginDescribeClientVpnEndpoints(DescribeClientVpnEndpointsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnEndpointsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeClientVpnEndpoints operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeClientVpnEndpoints.</param>
        /// 
        /// <returns>Returns a  DescribeClientVpnEndpointsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnEndpoints">REST API Reference for DescribeClientVpnEndpoints Operation</seealso>
        public virtual DescribeClientVpnEndpointsResponse EndDescribeClientVpnEndpoints(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeClientVpnEndpointsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeClientVpnRoutes

        /// <summary>
        /// Describes the routes for the specified Client VPN endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnRoutes service method.</param>
        /// 
        /// <returns>The response from the DescribeClientVpnRoutes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnRoutes">REST API Reference for DescribeClientVpnRoutes Operation</seealso>
        public virtual DescribeClientVpnRoutesResponse DescribeClientVpnRoutes(DescribeClientVpnRoutesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnRoutesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnRoutesResponseUnmarshaller.Instance;

            return Invoke<DescribeClientVpnRoutesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeClientVpnRoutes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnRoutes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClientVpnRoutes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnRoutes">REST API Reference for DescribeClientVpnRoutes Operation</seealso>
        public virtual IAsyncResult BeginDescribeClientVpnRoutes(DescribeClientVpnRoutesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnRoutesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnRoutesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeClientVpnRoutes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeClientVpnRoutes.</param>
        /// 
        /// <returns>Returns a  DescribeClientVpnRoutesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnRoutes">REST API Reference for DescribeClientVpnRoutes Operation</seealso>
        public virtual DescribeClientVpnRoutesResponse EndDescribeClientVpnRoutes(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeClientVpnRoutesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeClientVpnTargetNetworks

        /// <summary>
        /// Describes the target networks associated with the specified Client VPN endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnTargetNetworks service method.</param>
        /// 
        /// <returns>The response from the DescribeClientVpnTargetNetworks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnTargetNetworks">REST API Reference for DescribeClientVpnTargetNetworks Operation</seealso>
        public virtual DescribeClientVpnTargetNetworksResponse DescribeClientVpnTargetNetworks(DescribeClientVpnTargetNetworksRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnTargetNetworksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnTargetNetworksResponseUnmarshaller.Instance;

            return Invoke<DescribeClientVpnTargetNetworksResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeClientVpnTargetNetworks operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeClientVpnTargetNetworks operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClientVpnTargetNetworks
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnTargetNetworks">REST API Reference for DescribeClientVpnTargetNetworks Operation</seealso>
        public virtual IAsyncResult BeginDescribeClientVpnTargetNetworks(DescribeClientVpnTargetNetworksRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeClientVpnTargetNetworksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeClientVpnTargetNetworksResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeClientVpnTargetNetworks operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeClientVpnTargetNetworks.</param>
        /// 
        /// <returns>Returns a  DescribeClientVpnTargetNetworksResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeClientVpnTargetNetworks">REST API Reference for DescribeClientVpnTargetNetworks Operation</seealso>
        public virtual DescribeClientVpnTargetNetworksResponse EndDescribeClientVpnTargetNetworks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeClientVpnTargetNetworksResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeCoipPools

        /// <summary>
        /// Describes the specified customer-owned address pools or all of your customer-owned
        /// address pools.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeCoipPools service method.</param>
        /// 
        /// <returns>The response from the DescribeCoipPools service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCoipPools">REST API Reference for DescribeCoipPools Operation</seealso>
        public virtual DescribeCoipPoolsResponse DescribeCoipPools(DescribeCoipPoolsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCoipPoolsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCoipPoolsResponseUnmarshaller.Instance;

            return Invoke<DescribeCoipPoolsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeCoipPools operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeCoipPools operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeCoipPools
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCoipPools">REST API Reference for DescribeCoipPools Operation</seealso>
        public virtual IAsyncResult BeginDescribeCoipPools(DescribeCoipPoolsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCoipPoolsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCoipPoolsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeCoipPools operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeCoipPools.</param>
        /// 
        /// <returns>Returns a  DescribeCoipPoolsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCoipPools">REST API Reference for DescribeCoipPools Operation</seealso>
        public virtual DescribeCoipPoolsResponse EndDescribeCoipPools(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeCoipPoolsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeConversionTasks

        /// <summary>
        /// Describes the specified conversion tasks or all your conversion tasks. For more information,
        /// see the <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/">VM Import/Export
        /// User Guide</a>.
        /// 
        ///  
        /// <para>
        /// For information about the import manifest referenced by this API action, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM
        /// Import Manifest</a>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeConversionTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeConversionTasks">REST API Reference for DescribeConversionTasks Operation</seealso>
        public virtual DescribeConversionTasksResponse DescribeConversionTasks()
        {
            return DescribeConversionTasks(new DescribeConversionTasksRequest());
        }

        /// <summary>
        /// Describes the specified conversion tasks or all your conversion tasks. For more information,
        /// see the <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/">VM Import/Export
        /// User Guide</a>.
        /// 
        ///  
        /// <para>
        /// For information about the import manifest referenced by this API action, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM
        /// Import Manifest</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeConversionTasks service method.</param>
        /// 
        /// <returns>The response from the DescribeConversionTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeConversionTasks">REST API Reference for DescribeConversionTasks Operation</seealso>
        public virtual DescribeConversionTasksResponse DescribeConversionTasks(DescribeConversionTasksRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeConversionTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeConversionTasksResponseUnmarshaller.Instance;

            return Invoke<DescribeConversionTasksResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeConversionTasks operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeConversionTasks operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeConversionTasks
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeConversionTasks">REST API Reference for DescribeConversionTasks Operation</seealso>
        public virtual IAsyncResult BeginDescribeConversionTasks(DescribeConversionTasksRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeConversionTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeConversionTasksResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeConversionTasks operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeConversionTasks.</param>
        /// 
        /// <returns>Returns a  DescribeConversionTasksResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeConversionTasks">REST API Reference for DescribeConversionTasks Operation</seealso>
        public virtual DescribeConversionTasksResponse EndDescribeConversionTasks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeConversionTasksResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeCustomerGateways

        /// <summary>
        /// Describes one or more of your VPN customer gateways.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeCustomerGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCustomerGateways">REST API Reference for DescribeCustomerGateways Operation</seealso>
        public virtual DescribeCustomerGatewaysResponse DescribeCustomerGateways()
        {
            return DescribeCustomerGateways(new DescribeCustomerGatewaysRequest());
        }

        /// <summary>
        /// Describes one or more of your VPN customer gateways.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeCustomerGateways service method.</param>
        /// 
        /// <returns>The response from the DescribeCustomerGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCustomerGateways">REST API Reference for DescribeCustomerGateways Operation</seealso>
        public virtual DescribeCustomerGatewaysResponse DescribeCustomerGateways(DescribeCustomerGatewaysRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCustomerGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCustomerGatewaysResponseUnmarshaller.Instance;

            return Invoke<DescribeCustomerGatewaysResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeCustomerGateways operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeCustomerGateways operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeCustomerGateways
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCustomerGateways">REST API Reference for DescribeCustomerGateways Operation</seealso>
        public virtual IAsyncResult BeginDescribeCustomerGateways(DescribeCustomerGatewaysRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeCustomerGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeCustomerGatewaysResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeCustomerGateways operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeCustomerGateways.</param>
        /// 
        /// <returns>Returns a  DescribeCustomerGatewaysResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeCustomerGateways">REST API Reference for DescribeCustomerGateways Operation</seealso>
        public virtual DescribeCustomerGatewaysResponse EndDescribeCustomerGateways(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeCustomerGatewaysResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeDhcpOptions

        /// <summary>
        /// Describes one or more of your DHCP options sets.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP
        /// options sets</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeDhcpOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeDhcpOptions">REST API Reference for DescribeDhcpOptions Operation</seealso>
        public virtual DescribeDhcpOptionsResponse DescribeDhcpOptions()
        {
            return DescribeDhcpOptions(new DescribeDhcpOptionsRequest());
        }

        /// <summary>
        /// Describes one or more of your DHCP options sets.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html">DHCP
        /// options sets</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeDhcpOptions service method.</param>
        /// 
        /// <returns>The response from the DescribeDhcpOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeDhcpOptions">REST API Reference for DescribeDhcpOptions Operation</seealso>
        public virtual DescribeDhcpOptionsResponse DescribeDhcpOptions(DescribeDhcpOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeDhcpOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeDhcpOptionsResponseUnmarshaller.Instance;

            return Invoke<DescribeDhcpOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeDhcpOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeDhcpOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeDhcpOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeDhcpOptions">REST API Reference for DescribeDhcpOptions Operation</seealso>
        public virtual IAsyncResult BeginDescribeDhcpOptions(DescribeDhcpOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeDhcpOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeDhcpOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeDhcpOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeDhcpOptions.</param>
        /// 
        /// <returns>Returns a  DescribeDhcpOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeDhcpOptions">REST API Reference for DescribeDhcpOptions Operation</seealso>
        public virtual DescribeDhcpOptionsResponse EndDescribeDhcpOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeDhcpOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeEgressOnlyInternetGateways

        /// <summary>
        /// Describes one or more of your egress-only internet gateways.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeEgressOnlyInternetGateways service method.</param>
        /// 
        /// <returns>The response from the DescribeEgressOnlyInternetGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeEgressOnlyInternetGateways">REST API Reference for DescribeEgressOnlyInternetGateways Operation</seealso>
        public virtual DescribeEgressOnlyInternetGatewaysResponse DescribeEgressOnlyInternetGateways(DescribeEgressOnlyInternetGatewaysRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeEgressOnlyInternetGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeEgressOnlyInternetGatewaysResponseUnmarshaller.Instance;

            return Invoke<DescribeEgressOnlyInternetGatewaysResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeEgressOnlyInternetGateways operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeEgressOnlyInternetGateways operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeEgressOnlyInternetGateways
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeEgressOnlyInternetGateways">REST API Reference for DescribeEgressOnlyInternetGateways Operation</seealso>
        public virtual IAsyncResult BeginDescribeEgressOnlyInternetGateways(DescribeEgressOnlyInternetGatewaysRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeEgressOnlyInternetGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeEgressOnlyInternetGatewaysResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeEgressOnlyInternetGateways operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeEgressOnlyInternetGateways.</param>
        /// 
        /// <returns>Returns a  DescribeEgressOnlyInternetGatewaysResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeEgressOnlyInternetGateways">REST API Reference for DescribeEgressOnlyInternetGateways Operation</seealso>
        public virtual DescribeEgressOnlyInternetGatewaysResponse EndDescribeEgressOnlyInternetGateways(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeEgressOnlyInternetGatewaysResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeElasticGpus

        /// <summary>
        /// Describes the Elastic Graphics accelerator associated with your instances. For more
        /// information about Elastic Graphics, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/elastic-graphics.html">Amazon
        /// Elastic Graphics</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeElasticGpus service method.</param>
        /// 
        /// <returns>The response from the DescribeElasticGpus service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeElasticGpus">REST API Reference for DescribeElasticGpus Operation</seealso>
        public virtual DescribeElasticGpusResponse DescribeElasticGpus(DescribeElasticGpusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeElasticGpusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeElasticGpusResponseUnmarshaller.Instance;

            return Invoke<DescribeElasticGpusResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeElasticGpus operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeElasticGpus operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeElasticGpus
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeElasticGpus">REST API Reference for DescribeElasticGpus Operation</seealso>
        public virtual IAsyncResult BeginDescribeElasticGpus(DescribeElasticGpusRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeElasticGpusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeElasticGpusResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeElasticGpus operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeElasticGpus.</param>
        /// 
        /// <returns>Returns a  DescribeElasticGpusResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeElasticGpus">REST API Reference for DescribeElasticGpus Operation</seealso>
        public virtual DescribeElasticGpusResponse EndDescribeElasticGpus(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeElasticGpusResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeExportImageTasks

        /// <summary>
        /// Describes the specified export image tasks or all of your export image tasks.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeExportImageTasks service method.</param>
        /// 
        /// <returns>The response from the DescribeExportImageTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeExportImageTasks">REST API Reference for DescribeExportImageTasks Operation</seealso>
        public virtual DescribeExportImageTasksResponse DescribeExportImageTasks(DescribeExportImageTasksRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeExportImageTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeExportImageTasksResponseUnmarshaller.Instance;

            return Invoke<DescribeExportImageTasksResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeExportImageTasks operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeExportImageTasks operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeExportImageTasks
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeExportImageTasks">REST API Reference for DescribeExportImageTasks Operation</seealso>
        public virtual IAsyncResult BeginDescribeExportImageTasks(DescribeExportImageTasksRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeExportImageTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeExportImageTasksResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeExportImageTasks operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeExportImageTasks.</param>
        /// 
        /// <returns>Returns a  DescribeExportImageTasksResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeExportImageTasks">REST API Reference for DescribeExportImageTasks Operation</seealso>
        public virtual DescribeExportImageTasksResponse EndDescribeExportImageTasks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeExportImageTasksResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeExportTasks

        /// <summary>
        /// Describes the specified export instance tasks or all of your export instance tasks.
        /// </summary>
        /// 
        /// <returns>The response from the DescribeExportTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeExportTasks">REST API Reference for DescribeExportTasks Operation</seealso>
        public virtual DescribeExportTasksResponse DescribeExportTasks()
        {
            return DescribeExportTasks(new DescribeExportTasksRequest());
        }

        /// <summary>
        /// Describes the specified export instance tasks or all of your export instance tasks.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeExportTasks service method.</param>
        /// 
        /// <returns>The response from the DescribeExportTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeExportTasks">REST API Reference for DescribeExportTasks Operation</seealso>
        public virtual DescribeExportTasksResponse DescribeExportTasks(DescribeExportTasksRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeExportTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeExportTasksResponseUnmarshaller.Instance;

            return Invoke<DescribeExportTasksResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeExportTasks operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeExportTasks operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeExportTasks
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeExportTasks">REST API Reference for DescribeExportTasks Operation</seealso>
        public virtual IAsyncResult BeginDescribeExportTasks(DescribeExportTasksRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeExportTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeExportTasksResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeExportTasks operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeExportTasks.</param>
        /// 
        /// <returns>Returns a  DescribeExportTasksResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeExportTasks">REST API Reference for DescribeExportTasks Operation</seealso>
        public virtual DescribeExportTasksResponse EndDescribeExportTasks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeExportTasksResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeFastLaunchImages

        /// <summary>
        /// Describe details for Windows AMIs that are configured for faster launching.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeFastLaunchImages service method.</param>
        /// 
        /// <returns>The response from the DescribeFastLaunchImages service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFastLaunchImages">REST API Reference for DescribeFastLaunchImages Operation</seealso>
        public virtual DescribeFastLaunchImagesResponse DescribeFastLaunchImages(DescribeFastLaunchImagesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFastLaunchImagesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFastLaunchImagesResponseUnmarshaller.Instance;

            return Invoke<DescribeFastLaunchImagesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeFastLaunchImages operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeFastLaunchImages operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeFastLaunchImages
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFastLaunchImages">REST API Reference for DescribeFastLaunchImages Operation</seealso>
        public virtual IAsyncResult BeginDescribeFastLaunchImages(DescribeFastLaunchImagesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFastLaunchImagesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFastLaunchImagesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeFastLaunchImages operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeFastLaunchImages.</param>
        /// 
        /// <returns>Returns a  DescribeFastLaunchImagesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFastLaunchImages">REST API Reference for DescribeFastLaunchImages Operation</seealso>
        public virtual DescribeFastLaunchImagesResponse EndDescribeFastLaunchImages(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeFastLaunchImagesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeFastSnapshotRestores

        /// <summary>
        /// Describes the state of fast snapshot restores for your snapshots.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeFastSnapshotRestores service method.</param>
        /// 
        /// <returns>The response from the DescribeFastSnapshotRestores service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFastSnapshotRestores">REST API Reference for DescribeFastSnapshotRestores Operation</seealso>
        public virtual DescribeFastSnapshotRestoresResponse DescribeFastSnapshotRestores(DescribeFastSnapshotRestoresRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFastSnapshotRestoresRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFastSnapshotRestoresResponseUnmarshaller.Instance;

            return Invoke<DescribeFastSnapshotRestoresResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeFastSnapshotRestores operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeFastSnapshotRestores operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeFastSnapshotRestores
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFastSnapshotRestores">REST API Reference for DescribeFastSnapshotRestores Operation</seealso>
        public virtual IAsyncResult BeginDescribeFastSnapshotRestores(DescribeFastSnapshotRestoresRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFastSnapshotRestoresRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFastSnapshotRestoresResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeFastSnapshotRestores operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeFastSnapshotRestores.</param>
        /// 
        /// <returns>Returns a  DescribeFastSnapshotRestoresResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFastSnapshotRestores">REST API Reference for DescribeFastSnapshotRestores Operation</seealso>
        public virtual DescribeFastSnapshotRestoresResponse EndDescribeFastSnapshotRestores(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeFastSnapshotRestoresResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeFleetHistory

        /// <summary>
        /// Describes the events for the specified EC2 Fleet during the specified time.
        /// 
        ///  
        /// <para>
        /// EC2 Fleet events are delayed by up to 30 seconds before they can be described. This
        /// ensures that you can query by the last evaluated time and not miss a recorded event.
        /// EC2 Fleet events are available for 48 hours.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/fleet-monitor.html">Monitor
        /// fleet events using Amazon EventBridge</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeFleetHistory service method.</param>
        /// 
        /// <returns>The response from the DescribeFleetHistory service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleetHistory">REST API Reference for DescribeFleetHistory Operation</seealso>
        public virtual DescribeFleetHistoryResponse DescribeFleetHistory(DescribeFleetHistoryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFleetHistoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFleetHistoryResponseUnmarshaller.Instance;

            return Invoke<DescribeFleetHistoryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeFleetHistory operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeFleetHistory operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeFleetHistory
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleetHistory">REST API Reference for DescribeFleetHistory Operation</seealso>
        public virtual IAsyncResult BeginDescribeFleetHistory(DescribeFleetHistoryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFleetHistoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFleetHistoryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeFleetHistory operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeFleetHistory.</param>
        /// 
        /// <returns>Returns a  DescribeFleetHistoryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleetHistory">REST API Reference for DescribeFleetHistory Operation</seealso>
        public virtual DescribeFleetHistoryResponse EndDescribeFleetHistory(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeFleetHistoryResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeFleetInstances

        /// <summary>
        /// Describes the running instances for the specified EC2 Fleet.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#monitor-ec2-fleet">Monitor
        /// your EC2 Fleet</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeFleetInstances service method.</param>
        /// 
        /// <returns>The response from the DescribeFleetInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleetInstances">REST API Reference for DescribeFleetInstances Operation</seealso>
        public virtual DescribeFleetInstancesResponse DescribeFleetInstances(DescribeFleetInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFleetInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFleetInstancesResponseUnmarshaller.Instance;

            return Invoke<DescribeFleetInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeFleetInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeFleetInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeFleetInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleetInstances">REST API Reference for DescribeFleetInstances Operation</seealso>
        public virtual IAsyncResult BeginDescribeFleetInstances(DescribeFleetInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFleetInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFleetInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeFleetInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeFleetInstances.</param>
        /// 
        /// <returns>Returns a  DescribeFleetInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleetInstances">REST API Reference for DescribeFleetInstances Operation</seealso>
        public virtual DescribeFleetInstancesResponse EndDescribeFleetInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeFleetInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeFleets

        /// <summary>
        /// Describes the specified EC2 Fleets or all of your EC2 Fleets.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/manage-ec2-fleet.html#monitor-ec2-fleet">Monitor
        /// your EC2 Fleet</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeFleets service method.</param>
        /// 
        /// <returns>The response from the DescribeFleets service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleets">REST API Reference for DescribeFleets Operation</seealso>
        public virtual DescribeFleetsResponse DescribeFleets(DescribeFleetsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFleetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFleetsResponseUnmarshaller.Instance;

            return Invoke<DescribeFleetsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeFleets operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeFleets operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeFleets
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleets">REST API Reference for DescribeFleets Operation</seealso>
        public virtual IAsyncResult BeginDescribeFleets(DescribeFleetsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFleetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFleetsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeFleets operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeFleets.</param>
        /// 
        /// <returns>Returns a  DescribeFleetsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFleets">REST API Reference for DescribeFleets Operation</seealso>
        public virtual DescribeFleetsResponse EndDescribeFleets(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeFleetsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeFlowLogs

        /// <summary>
        /// Describes one or more flow logs.
        /// 
        ///  
        /// <para>
        /// To view the published flow log records, you must view the log destination. For example,
        /// the CloudWatch Logs log group, the Amazon S3 bucket, or the Kinesis Data Firehose
        /// delivery stream.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeFlowLogs service method.</param>
        /// 
        /// <returns>The response from the DescribeFlowLogs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFlowLogs">REST API Reference for DescribeFlowLogs Operation</seealso>
        public virtual DescribeFlowLogsResponse DescribeFlowLogs(DescribeFlowLogsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFlowLogsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFlowLogsResponseUnmarshaller.Instance;

            return Invoke<DescribeFlowLogsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeFlowLogs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeFlowLogs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeFlowLogs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFlowLogs">REST API Reference for DescribeFlowLogs Operation</seealso>
        public virtual IAsyncResult BeginDescribeFlowLogs(DescribeFlowLogsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFlowLogsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFlowLogsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeFlowLogs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeFlowLogs.</param>
        /// 
        /// <returns>Returns a  DescribeFlowLogsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFlowLogs">REST API Reference for DescribeFlowLogs Operation</seealso>
        public virtual DescribeFlowLogsResponse EndDescribeFlowLogs(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeFlowLogsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeFpgaImageAttribute

        /// <summary>
        /// Describes the specified attribute of the specified Amazon FPGA Image (AFI).
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeFpgaImageAttribute service method.</param>
        /// 
        /// <returns>The response from the DescribeFpgaImageAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFpgaImageAttribute">REST API Reference for DescribeFpgaImageAttribute Operation</seealso>
        public virtual DescribeFpgaImageAttributeResponse DescribeFpgaImageAttribute(DescribeFpgaImageAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFpgaImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFpgaImageAttributeResponseUnmarshaller.Instance;

            return Invoke<DescribeFpgaImageAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeFpgaImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeFpgaImageAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeFpgaImageAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFpgaImageAttribute">REST API Reference for DescribeFpgaImageAttribute Operation</seealso>
        public virtual IAsyncResult BeginDescribeFpgaImageAttribute(DescribeFpgaImageAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFpgaImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFpgaImageAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeFpgaImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeFpgaImageAttribute.</param>
        /// 
        /// <returns>Returns a  DescribeFpgaImageAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFpgaImageAttribute">REST API Reference for DescribeFpgaImageAttribute Operation</seealso>
        public virtual DescribeFpgaImageAttributeResponse EndDescribeFpgaImageAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeFpgaImageAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeFpgaImages

        /// <summary>
        /// Describes the Amazon FPGA Images (AFIs) available to you. These include public AFIs,
        /// private AFIs that you own, and AFIs owned by other Amazon Web Services accounts for
        /// which you have load permissions.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeFpgaImages service method.</param>
        /// 
        /// <returns>The response from the DescribeFpgaImages service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFpgaImages">REST API Reference for DescribeFpgaImages Operation</seealso>
        public virtual DescribeFpgaImagesResponse DescribeFpgaImages(DescribeFpgaImagesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFpgaImagesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFpgaImagesResponseUnmarshaller.Instance;

            return Invoke<DescribeFpgaImagesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeFpgaImages operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeFpgaImages operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeFpgaImages
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFpgaImages">REST API Reference for DescribeFpgaImages Operation</seealso>
        public virtual IAsyncResult BeginDescribeFpgaImages(DescribeFpgaImagesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeFpgaImagesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeFpgaImagesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeFpgaImages operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeFpgaImages.</param>
        /// 
        /// <returns>Returns a  DescribeFpgaImagesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeFpgaImages">REST API Reference for DescribeFpgaImages Operation</seealso>
        public virtual DescribeFpgaImagesResponse EndDescribeFpgaImages(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeFpgaImagesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeHostReservationOfferings

        /// <summary>
        /// Describes the Dedicated Host reservations that are available to purchase.
        /// 
        ///  
        /// <para>
        /// The results describe all of the Dedicated Host reservation offerings, including offerings
        /// that might not match the instance family and Region of your Dedicated Hosts. When
        /// purchasing an offering, ensure that the instance family and Region of the offering
        /// matches that of the Dedicated Hosts with which it is to be associated. For more information
        /// about supported instance types, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-overview.html">Dedicated
        /// Hosts</a> in the <i>Amazon EC2 User Guide</i>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeHostReservationOfferings service method.</param>
        /// 
        /// <returns>The response from the DescribeHostReservationOfferings service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHostReservationOfferings">REST API Reference for DescribeHostReservationOfferings Operation</seealso>
        public virtual DescribeHostReservationOfferingsResponse DescribeHostReservationOfferings(DescribeHostReservationOfferingsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeHostReservationOfferingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeHostReservationOfferingsResponseUnmarshaller.Instance;

            return Invoke<DescribeHostReservationOfferingsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeHostReservationOfferings operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeHostReservationOfferings operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeHostReservationOfferings
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHostReservationOfferings">REST API Reference for DescribeHostReservationOfferings Operation</seealso>
        public virtual IAsyncResult BeginDescribeHostReservationOfferings(DescribeHostReservationOfferingsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeHostReservationOfferingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeHostReservationOfferingsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeHostReservationOfferings operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeHostReservationOfferings.</param>
        /// 
        /// <returns>Returns a  DescribeHostReservationOfferingsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHostReservationOfferings">REST API Reference for DescribeHostReservationOfferings Operation</seealso>
        public virtual DescribeHostReservationOfferingsResponse EndDescribeHostReservationOfferings(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeHostReservationOfferingsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeHostReservations

        /// <summary>
        /// Describes reservations that are associated with Dedicated Hosts in your account.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeHostReservations service method.</param>
        /// 
        /// <returns>The response from the DescribeHostReservations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHostReservations">REST API Reference for DescribeHostReservations Operation</seealso>
        public virtual DescribeHostReservationsResponse DescribeHostReservations(DescribeHostReservationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeHostReservationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeHostReservationsResponseUnmarshaller.Instance;

            return Invoke<DescribeHostReservationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeHostReservations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeHostReservations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeHostReservations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHostReservations">REST API Reference for DescribeHostReservations Operation</seealso>
        public virtual IAsyncResult BeginDescribeHostReservations(DescribeHostReservationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeHostReservationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeHostReservationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeHostReservations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeHostReservations.</param>
        /// 
        /// <returns>Returns a  DescribeHostReservationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHostReservations">REST API Reference for DescribeHostReservations Operation</seealso>
        public virtual DescribeHostReservationsResponse EndDescribeHostReservations(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeHostReservationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeHosts

        /// <summary>
        /// Describes the specified Dedicated Hosts or all your Dedicated Hosts.
        /// 
        ///  
        /// <para>
        /// The results describe only the Dedicated Hosts in the Region you're currently using.
        /// All listed instances consume capacity on your Dedicated Host. Dedicated Hosts that
        /// have recently been released are listed with the state <code>released</code>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeHosts service method.</param>
        /// 
        /// <returns>The response from the DescribeHosts service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHosts">REST API Reference for DescribeHosts Operation</seealso>
        public virtual DescribeHostsResponse DescribeHosts(DescribeHostsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeHostsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeHostsResponseUnmarshaller.Instance;

            return Invoke<DescribeHostsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeHosts operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeHosts operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeHosts
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHosts">REST API Reference for DescribeHosts Operation</seealso>
        public virtual IAsyncResult BeginDescribeHosts(DescribeHostsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeHostsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeHostsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeHosts operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeHosts.</param>
        /// 
        /// <returns>Returns a  DescribeHostsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeHosts">REST API Reference for DescribeHosts Operation</seealso>
        public virtual DescribeHostsResponse EndDescribeHosts(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeHostsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeIamInstanceProfileAssociations

        /// <summary>
        /// Describes your IAM instance profile associations.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeIamInstanceProfileAssociations service method.</param>
        /// 
        /// <returns>The response from the DescribeIamInstanceProfileAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIamInstanceProfileAssociations">REST API Reference for DescribeIamInstanceProfileAssociations Operation</seealso>
        public virtual DescribeIamInstanceProfileAssociationsResponse DescribeIamInstanceProfileAssociations(DescribeIamInstanceProfileAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIamInstanceProfileAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIamInstanceProfileAssociationsResponseUnmarshaller.Instance;

            return Invoke<DescribeIamInstanceProfileAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeIamInstanceProfileAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeIamInstanceProfileAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeIamInstanceProfileAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIamInstanceProfileAssociations">REST API Reference for DescribeIamInstanceProfileAssociations Operation</seealso>
        public virtual IAsyncResult BeginDescribeIamInstanceProfileAssociations(DescribeIamInstanceProfileAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIamInstanceProfileAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIamInstanceProfileAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeIamInstanceProfileAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeIamInstanceProfileAssociations.</param>
        /// 
        /// <returns>Returns a  DescribeIamInstanceProfileAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIamInstanceProfileAssociations">REST API Reference for DescribeIamInstanceProfileAssociations Operation</seealso>
        public virtual DescribeIamInstanceProfileAssociationsResponse EndDescribeIamInstanceProfileAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeIamInstanceProfileAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeIdentityIdFormat

        /// <summary>
        /// Describes the ID format settings for resources for the specified IAM user, IAM role,
        /// or root user. For example, you can view the resource types that are enabled for longer
        /// IDs. This request only returns information about resource types whose ID formats can
        /// be modified; it does not return information about other resource types. For more information,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/resource-ids.html">Resource
        /// IDs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. 
        /// 
        ///  
        /// <para>
        /// The following resource types support longer IDs: <code>bundle</code> | <code>conversion-task</code>
        /// | <code>customer-gateway</code> | <code>dhcp-options</code> | <code>elastic-ip-allocation</code>
        /// | <code>elastic-ip-association</code> | <code>export-task</code> | <code>flow-log</code>
        /// | <code>image</code> | <code>import-task</code> | <code>instance</code> | <code>internet-gateway</code>
        /// | <code>network-acl</code> | <code>network-acl-association</code> | <code>network-interface</code>
        /// | <code>network-interface-attachment</code> | <code>prefix-list</code> | <code>reservation</code>
        /// | <code>route-table</code> | <code>route-table-association</code> | <code>security-group</code>
        /// | <code>snapshot</code> | <code>subnet</code> | <code>subnet-cidr-block-association</code>
        /// | <code>volume</code> | <code>vpc</code> | <code>vpc-cidr-block-association</code>
        /// | <code>vpc-endpoint</code> | <code>vpc-peering-connection</code> | <code>vpn-connection</code>
        /// | <code>vpn-gateway</code>. 
        /// </para>
        ///  
        /// <para>
        /// These settings apply to the principal specified in the request. They do not apply
        /// to the principal that makes the request.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeIdentityIdFormat service method.</param>
        /// 
        /// <returns>The response from the DescribeIdentityIdFormat service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIdentityIdFormat">REST API Reference for DescribeIdentityIdFormat Operation</seealso>
        public virtual DescribeIdentityIdFormatResponse DescribeIdentityIdFormat(DescribeIdentityIdFormatRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIdentityIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIdentityIdFormatResponseUnmarshaller.Instance;

            return Invoke<DescribeIdentityIdFormatResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeIdentityIdFormat operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeIdentityIdFormat operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeIdentityIdFormat
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIdentityIdFormat">REST API Reference for DescribeIdentityIdFormat Operation</seealso>
        public virtual IAsyncResult BeginDescribeIdentityIdFormat(DescribeIdentityIdFormatRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIdentityIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIdentityIdFormatResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeIdentityIdFormat operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeIdentityIdFormat.</param>
        /// 
        /// <returns>Returns a  DescribeIdentityIdFormatResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIdentityIdFormat">REST API Reference for DescribeIdentityIdFormat Operation</seealso>
        public virtual DescribeIdentityIdFormatResponse EndDescribeIdentityIdFormat(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeIdentityIdFormatResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeIdFormat

        /// <summary>
        /// Describes the ID format settings for your resources on a per-Region basis, for example,
        /// to view which resource types are enabled for longer IDs. This request only returns
        /// information about resource types whose ID formats can be modified; it does not return
        /// information about other resource types.
        /// 
        ///  
        /// <para>
        /// The following resource types support longer IDs: <code>bundle</code> | <code>conversion-task</code>
        /// | <code>customer-gateway</code> | <code>dhcp-options</code> | <code>elastic-ip-allocation</code>
        /// | <code>elastic-ip-association</code> | <code>export-task</code> | <code>flow-log</code>
        /// | <code>image</code> | <code>import-task</code> | <code>instance</code> | <code>internet-gateway</code>
        /// | <code>network-acl</code> | <code>network-acl-association</code> | <code>network-interface</code>
        /// | <code>network-interface-attachment</code> | <code>prefix-list</code> | <code>reservation</code>
        /// | <code>route-table</code> | <code>route-table-association</code> | <code>security-group</code>
        /// | <code>snapshot</code> | <code>subnet</code> | <code>subnet-cidr-block-association</code>
        /// | <code>volume</code> | <code>vpc</code> | <code>vpc-cidr-block-association</code>
        /// | <code>vpc-endpoint</code> | <code>vpc-peering-connection</code> | <code>vpn-connection</code>
        /// | <code>vpn-gateway</code>. 
        /// </para>
        ///  
        /// <para>
        /// These settings apply to the IAM user who makes the request; they do not apply to the
        /// entire Amazon Web Services account. By default, an IAM user defaults to the same settings
        /// as the root user, unless they explicitly override the settings by running the <a>ModifyIdFormat</a>
        /// command. Resources created with longer IDs are visible to all IAM users, regardless
        /// of these settings and provided that they have permission to use the relevant <code>Describe</code>
        /// command for the resource type.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeIdFormat service method.</param>
        /// 
        /// <returns>The response from the DescribeIdFormat service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIdFormat">REST API Reference for DescribeIdFormat Operation</seealso>
        public virtual DescribeIdFormatResponse DescribeIdFormat(DescribeIdFormatRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIdFormatResponseUnmarshaller.Instance;

            return Invoke<DescribeIdFormatResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeIdFormat operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeIdFormat operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeIdFormat
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIdFormat">REST API Reference for DescribeIdFormat Operation</seealso>
        public virtual IAsyncResult BeginDescribeIdFormat(DescribeIdFormatRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIdFormatResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeIdFormat operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeIdFormat.</param>
        /// 
        /// <returns>Returns a  DescribeIdFormatResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIdFormat">REST API Reference for DescribeIdFormat Operation</seealso>
        public virtual DescribeIdFormatResponse EndDescribeIdFormat(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeIdFormatResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeImageAttribute

        /// <summary>
        /// Describes the specified attribute of the specified AMI. You can specify only one attribute
        /// at a time.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeImageAttribute service method.</param>
        /// 
        /// <returns>The response from the DescribeImageAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImageAttribute">REST API Reference for DescribeImageAttribute Operation</seealso>
        public virtual DescribeImageAttributeResponse DescribeImageAttribute(DescribeImageAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeImageAttributeResponseUnmarshaller.Instance;

            return Invoke<DescribeImageAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeImageAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeImageAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImageAttribute">REST API Reference for DescribeImageAttribute Operation</seealso>
        public virtual IAsyncResult BeginDescribeImageAttribute(DescribeImageAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeImageAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeImageAttribute.</param>
        /// 
        /// <returns>Returns a  DescribeImageAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImageAttribute">REST API Reference for DescribeImageAttribute Operation</seealso>
        public virtual DescribeImageAttributeResponse EndDescribeImageAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeImageAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeImages

        /// <summary>
        /// Describes the specified images (AMIs, AKIs, and ARIs) available to you or all of the
        /// images available to you.
        /// 
        ///  
        /// <para>
        /// The images available to you include public images, private images that you own, and
        /// private images owned by other Amazon Web Services accounts for which you have explicit
        /// launch permissions.
        /// </para>
        ///  
        /// <para>
        /// Recently deregistered images appear in the returned results for a short interval and
        /// then return empty results. After all instances that reference a deregistered AMI are
        /// terminated, specifying the ID of the image will eventually return an error indicating
        /// that the AMI ID cannot be found.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeImages service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImages">REST API Reference for DescribeImages Operation</seealso>
        public virtual DescribeImagesResponse DescribeImages()
        {
            return DescribeImages(new DescribeImagesRequest());
        }

        /// <summary>
        /// Describes the specified images (AMIs, AKIs, and ARIs) available to you or all of the
        /// images available to you.
        /// 
        ///  
        /// <para>
        /// The images available to you include public images, private images that you own, and
        /// private images owned by other Amazon Web Services accounts for which you have explicit
        /// launch permissions.
        /// </para>
        ///  
        /// <para>
        /// Recently deregistered images appear in the returned results for a short interval and
        /// then return empty results. After all instances that reference a deregistered AMI are
        /// terminated, specifying the ID of the image will eventually return an error indicating
        /// that the AMI ID cannot be found.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeImages service method.</param>
        /// 
        /// <returns>The response from the DescribeImages service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImages">REST API Reference for DescribeImages Operation</seealso>
        public virtual DescribeImagesResponse DescribeImages(DescribeImagesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeImagesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeImagesResponseUnmarshaller.Instance;

            return Invoke<DescribeImagesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeImages operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeImages operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeImages
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImages">REST API Reference for DescribeImages Operation</seealso>
        public virtual IAsyncResult BeginDescribeImages(DescribeImagesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeImagesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeImagesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeImages operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeImages.</param>
        /// 
        /// <returns>Returns a  DescribeImagesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImages">REST API Reference for DescribeImages Operation</seealso>
        public virtual DescribeImagesResponse EndDescribeImages(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeImagesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeImportImageTasks

        /// <summary>
        /// Displays details about an import virtual machine or import snapshot tasks that are
        /// already created.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeImportImageTasks service method.</param>
        /// 
        /// <returns>The response from the DescribeImportImageTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImportImageTasks">REST API Reference for DescribeImportImageTasks Operation</seealso>
        public virtual DescribeImportImageTasksResponse DescribeImportImageTasks(DescribeImportImageTasksRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeImportImageTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeImportImageTasksResponseUnmarshaller.Instance;

            return Invoke<DescribeImportImageTasksResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeImportImageTasks operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeImportImageTasks operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeImportImageTasks
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImportImageTasks">REST API Reference for DescribeImportImageTasks Operation</seealso>
        public virtual IAsyncResult BeginDescribeImportImageTasks(DescribeImportImageTasksRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeImportImageTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeImportImageTasksResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeImportImageTasks operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeImportImageTasks.</param>
        /// 
        /// <returns>Returns a  DescribeImportImageTasksResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImportImageTasks">REST API Reference for DescribeImportImageTasks Operation</seealso>
        public virtual DescribeImportImageTasksResponse EndDescribeImportImageTasks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeImportImageTasksResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeImportSnapshotTasks

        /// <summary>
        /// Describes your import snapshot tasks.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeImportSnapshotTasks service method.</param>
        /// 
        /// <returns>The response from the DescribeImportSnapshotTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImportSnapshotTasks">REST API Reference for DescribeImportSnapshotTasks Operation</seealso>
        public virtual DescribeImportSnapshotTasksResponse DescribeImportSnapshotTasks(DescribeImportSnapshotTasksRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeImportSnapshotTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeImportSnapshotTasksResponseUnmarshaller.Instance;

            return Invoke<DescribeImportSnapshotTasksResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeImportSnapshotTasks operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeImportSnapshotTasks operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeImportSnapshotTasks
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImportSnapshotTasks">REST API Reference for DescribeImportSnapshotTasks Operation</seealso>
        public virtual IAsyncResult BeginDescribeImportSnapshotTasks(DescribeImportSnapshotTasksRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeImportSnapshotTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeImportSnapshotTasksResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeImportSnapshotTasks operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeImportSnapshotTasks.</param>
        /// 
        /// <returns>Returns a  DescribeImportSnapshotTasksResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeImportSnapshotTasks">REST API Reference for DescribeImportSnapshotTasks Operation</seealso>
        public virtual DescribeImportSnapshotTasksResponse EndDescribeImportSnapshotTasks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeImportSnapshotTasksResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInstanceAttribute

        /// <summary>
        /// Describes the specified attribute of the specified instance. You can specify only
        /// one attribute at a time. Valid attribute values are: <code>instanceType</code> | <code>kernel</code>
        /// | <code>ramdisk</code> | <code>userData</code> | <code>disableApiTermination</code>
        /// | <code>instanceInitiatedShutdownBehavior</code> | <code>rootDeviceName</code> | <code>blockDeviceMapping</code>
        /// | <code>productCodes</code> | <code>sourceDestCheck</code> | <code>groupSet</code>
        /// | <code>ebsOptimized</code> | <code>sriovNetSupport</code>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceAttribute service method.</param>
        /// 
        /// <returns>The response from the DescribeInstanceAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceAttribute">REST API Reference for DescribeInstanceAttribute Operation</seealso>
        public virtual DescribeInstanceAttributeResponse DescribeInstanceAttribute(DescribeInstanceAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceAttributeResponseUnmarshaller.Instance;

            return Invoke<DescribeInstanceAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstanceAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceAttribute">REST API Reference for DescribeInstanceAttribute Operation</seealso>
        public virtual IAsyncResult BeginDescribeInstanceAttribute(DescribeInstanceAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInstanceAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInstanceAttribute.</param>
        /// 
        /// <returns>Returns a  DescribeInstanceAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceAttribute">REST API Reference for DescribeInstanceAttribute Operation</seealso>
        public virtual DescribeInstanceAttributeResponse EndDescribeInstanceAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInstanceAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInstanceConnectEndpoints

        /// <summary>
        /// Describes the specified EC2 Instance Connect Endpoints or all EC2 Instance Connect
        /// Endpoints.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceConnectEndpoints service method.</param>
        /// 
        /// <returns>The response from the DescribeInstanceConnectEndpoints service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceConnectEndpoints">REST API Reference for DescribeInstanceConnectEndpoints Operation</seealso>
        public virtual DescribeInstanceConnectEndpointsResponse DescribeInstanceConnectEndpoints(DescribeInstanceConnectEndpointsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceConnectEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceConnectEndpointsResponseUnmarshaller.Instance;

            return Invoke<DescribeInstanceConnectEndpointsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstanceConnectEndpoints operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceConnectEndpoints operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceConnectEndpoints
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceConnectEndpoints">REST API Reference for DescribeInstanceConnectEndpoints Operation</seealso>
        public virtual IAsyncResult BeginDescribeInstanceConnectEndpoints(DescribeInstanceConnectEndpointsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceConnectEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceConnectEndpointsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInstanceConnectEndpoints operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInstanceConnectEndpoints.</param>
        /// 
        /// <returns>Returns a  DescribeInstanceConnectEndpointsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceConnectEndpoints">REST API Reference for DescribeInstanceConnectEndpoints Operation</seealso>
        public virtual DescribeInstanceConnectEndpointsResponse EndDescribeInstanceConnectEndpoints(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInstanceConnectEndpointsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInstanceCreditSpecifications

        /// <summary>
        /// Describes the credit option for CPU usage of the specified burstable performance instances.
        /// The credit options are <code>standard</code> and <code>unlimited</code>.
        /// 
        ///  
        /// <para>
        /// If you do not specify an instance ID, Amazon EC2 returns burstable performance instances
        /// with the <code>unlimited</code> credit option, as well as instances that were previously
        /// configured as T2, T3, and T3a with the <code>unlimited</code> credit option. For example,
        /// if you resize a T2 instance, while it is configured as <code>unlimited</code>, to
        /// an M4 instance, Amazon EC2 returns the M4 instance.
        /// </para>
        ///  
        /// <para>
        /// If you specify one or more instance IDs, Amazon EC2 returns the credit option (<code>standard</code>
        /// or <code>unlimited</code>) of those instances. If you specify an instance ID that
        /// is not valid, such as an instance that is not a burstable performance instance, an
        /// error is returned.
        /// </para>
        ///  
        /// <para>
        /// Recently terminated instances might appear in the returned results. This interval
        /// is usually less than one hour.
        /// </para>
        ///  
        /// <para>
        /// If an Availability Zone is experiencing a service disruption and you specify instance
        /// IDs in the affected zone, or do not specify any instance IDs at all, the call fails.
        /// If you specify only instance IDs in an unaffected zone, the call works normally.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html">Burstable
        /// performance instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceCreditSpecifications service method.</param>
        /// 
        /// <returns>The response from the DescribeInstanceCreditSpecifications service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceCreditSpecifications">REST API Reference for DescribeInstanceCreditSpecifications Operation</seealso>
        public virtual DescribeInstanceCreditSpecificationsResponse DescribeInstanceCreditSpecifications(DescribeInstanceCreditSpecificationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceCreditSpecificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceCreditSpecificationsResponseUnmarshaller.Instance;

            return Invoke<DescribeInstanceCreditSpecificationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstanceCreditSpecifications operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceCreditSpecifications operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceCreditSpecifications
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceCreditSpecifications">REST API Reference for DescribeInstanceCreditSpecifications Operation</seealso>
        public virtual IAsyncResult BeginDescribeInstanceCreditSpecifications(DescribeInstanceCreditSpecificationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceCreditSpecificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceCreditSpecificationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInstanceCreditSpecifications operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInstanceCreditSpecifications.</param>
        /// 
        /// <returns>Returns a  DescribeInstanceCreditSpecificationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceCreditSpecifications">REST API Reference for DescribeInstanceCreditSpecifications Operation</seealso>
        public virtual DescribeInstanceCreditSpecificationsResponse EndDescribeInstanceCreditSpecifications(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInstanceCreditSpecificationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInstanceEventNotificationAttributes

        /// <summary>
        /// Describes the tag keys that are registered to appear in scheduled event notifications
        /// for resources in the current Region.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceEventNotificationAttributes service method.</param>
        /// 
        /// <returns>The response from the DescribeInstanceEventNotificationAttributes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceEventNotificationAttributes">REST API Reference for DescribeInstanceEventNotificationAttributes Operation</seealso>
        public virtual DescribeInstanceEventNotificationAttributesResponse DescribeInstanceEventNotificationAttributes(DescribeInstanceEventNotificationAttributesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceEventNotificationAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceEventNotificationAttributesResponseUnmarshaller.Instance;

            return Invoke<DescribeInstanceEventNotificationAttributesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstanceEventNotificationAttributes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceEventNotificationAttributes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceEventNotificationAttributes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceEventNotificationAttributes">REST API Reference for DescribeInstanceEventNotificationAttributes Operation</seealso>
        public virtual IAsyncResult BeginDescribeInstanceEventNotificationAttributes(DescribeInstanceEventNotificationAttributesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceEventNotificationAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceEventNotificationAttributesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInstanceEventNotificationAttributes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInstanceEventNotificationAttributes.</param>
        /// 
        /// <returns>Returns a  DescribeInstanceEventNotificationAttributesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceEventNotificationAttributes">REST API Reference for DescribeInstanceEventNotificationAttributes Operation</seealso>
        public virtual DescribeInstanceEventNotificationAttributesResponse EndDescribeInstanceEventNotificationAttributes(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInstanceEventNotificationAttributesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInstanceEventWindows

        /// <summary>
        /// Describes the specified event windows or all event windows.
        /// 
        ///  
        /// <para>
        /// If you specify event window IDs, the output includes information for only the specified
        /// event windows. If you specify filters, the output includes information for only those
        /// event windows that meet the filter criteria. If you do not specify event windows IDs
        /// or filters, the output includes information for all event windows, which can affect
        /// performance. We recommend that you use pagination to ensure that the operation returns
        /// quickly and successfully. 
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
        /// event windows for scheduled events</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceEventWindows service method.</param>
        /// 
        /// <returns>The response from the DescribeInstanceEventWindows service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceEventWindows">REST API Reference for DescribeInstanceEventWindows Operation</seealso>
        public virtual DescribeInstanceEventWindowsResponse DescribeInstanceEventWindows(DescribeInstanceEventWindowsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceEventWindowsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceEventWindowsResponseUnmarshaller.Instance;

            return Invoke<DescribeInstanceEventWindowsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstanceEventWindows operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceEventWindows operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceEventWindows
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceEventWindows">REST API Reference for DescribeInstanceEventWindows Operation</seealso>
        public virtual IAsyncResult BeginDescribeInstanceEventWindows(DescribeInstanceEventWindowsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceEventWindowsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceEventWindowsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInstanceEventWindows operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInstanceEventWindows.</param>
        /// 
        /// <returns>Returns a  DescribeInstanceEventWindowsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceEventWindows">REST API Reference for DescribeInstanceEventWindows Operation</seealso>
        public virtual DescribeInstanceEventWindowsResponse EndDescribeInstanceEventWindows(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInstanceEventWindowsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInstances

        /// <summary>
        /// Describes the specified instances or all instances.
        /// 
        ///  
        /// <para>
        /// If you specify instance IDs, the output includes information for only the specified
        /// instances. If you specify filters, the output includes information for only those
        /// instances that meet the filter criteria. If you do not specify instance IDs or filters,
        /// the output includes information for all instances, which can affect performance. We
        /// recommend that you use pagination to ensure that the operation returns quickly and
        /// successfully.
        /// </para>
        ///  
        /// <para>
        /// If you specify an instance ID that is not valid, an error is returned. If you specify
        /// an instance that you do not own, it is not included in the output.
        /// </para>
        ///  
        /// <para>
        /// Recently terminated instances might appear in the returned results. This interval
        /// is usually less than one hour.
        /// </para>
        ///  
        /// <para>
        /// If you describe instances in the rare case where an Availability Zone is experiencing
        /// a service disruption and you specify instance IDs that are in the affected zone, or
        /// do not specify any instance IDs at all, the call fails. If you describe instances
        /// and specify only instance IDs that are in an unaffected zone, the call works normally.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstances">REST API Reference for DescribeInstances Operation</seealso>
        public virtual DescribeInstancesResponse DescribeInstances()
        {
            return DescribeInstances(new DescribeInstancesRequest());
        }

        /// <summary>
        /// Describes the specified instances or all instances.
        /// 
        ///  
        /// <para>
        /// If you specify instance IDs, the output includes information for only the specified
        /// instances. If you specify filters, the output includes information for only those
        /// instances that meet the filter criteria. If you do not specify instance IDs or filters,
        /// the output includes information for all instances, which can affect performance. We
        /// recommend that you use pagination to ensure that the operation returns quickly and
        /// successfully.
        /// </para>
        ///  
        /// <para>
        /// If you specify an instance ID that is not valid, an error is returned. If you specify
        /// an instance that you do not own, it is not included in the output.
        /// </para>
        ///  
        /// <para>
        /// Recently terminated instances might appear in the returned results. This interval
        /// is usually less than one hour.
        /// </para>
        ///  
        /// <para>
        /// If you describe instances in the rare case where an Availability Zone is experiencing
        /// a service disruption and you specify instance IDs that are in the affected zone, or
        /// do not specify any instance IDs at all, the call fails. If you describe instances
        /// and specify only instance IDs that are in an unaffected zone, the call works normally.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstances service method.</param>
        /// 
        /// <returns>The response from the DescribeInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstances">REST API Reference for DescribeInstances Operation</seealso>
        public virtual DescribeInstancesResponse DescribeInstances(DescribeInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstancesResponseUnmarshaller.Instance;

            return Invoke<DescribeInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstances">REST API Reference for DescribeInstances Operation</seealso>
        public virtual IAsyncResult BeginDescribeInstances(DescribeInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInstances.</param>
        /// 
        /// <returns>Returns a  DescribeInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstances">REST API Reference for DescribeInstances Operation</seealso>
        public virtual DescribeInstancesResponse EndDescribeInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInstanceStatus

        /// <summary>
        /// Describes the status of the specified instances or all of your instances. By default,
        /// only running instances are described, unless you specifically indicate to return the
        /// status of all instances.
        /// 
        ///  
        /// <para>
        /// Instance status includes the following components:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        ///  <b>Status checks</b> - Amazon EC2 performs status checks on running EC2 instances
        /// to identify hardware and software issues. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-system-instance-status-check.html">Status
        /// checks for your instances</a> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstances.html">Troubleshoot
        /// instances with failed status checks</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <b>Scheduled events</b> - Amazon EC2 can schedule events (such as reboot, stop, or
        /// terminate) for your instances related to hardware issues, software updates, or system
        /// maintenance. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html">Scheduled
        /// events for your instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <b>Instance state</b> - You can manage your instances from the moment you launch
        /// them through their termination. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Instance
        /// lifecycle</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  </li> </ul>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeInstanceStatus service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceStatus">REST API Reference for DescribeInstanceStatus Operation</seealso>
        public virtual DescribeInstanceStatusResponse DescribeInstanceStatus()
        {
            return DescribeInstanceStatus(new DescribeInstanceStatusRequest());
        }

        /// <summary>
        /// Describes the status of the specified instances or all of your instances. By default,
        /// only running instances are described, unless you specifically indicate to return the
        /// status of all instances.
        /// 
        ///  
        /// <para>
        /// Instance status includes the following components:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        ///  <b>Status checks</b> - Amazon EC2 performs status checks on running EC2 instances
        /// to identify hardware and software issues. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-system-instance-status-check.html">Status
        /// checks for your instances</a> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstances.html">Troubleshoot
        /// instances with failed status checks</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <b>Scheduled events</b> - Amazon EC2 can schedule events (such as reboot, stop, or
        /// terminate) for your instances related to hardware issues, software updates, or system
        /// maintenance. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html">Scheduled
        /// events for your instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <b>Instance state</b> - You can manage your instances from the moment you launch
        /// them through their termination. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Instance
        /// lifecycle</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  </li> </ul>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceStatus service method.</param>
        /// 
        /// <returns>The response from the DescribeInstanceStatus service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceStatus">REST API Reference for DescribeInstanceStatus Operation</seealso>
        public virtual DescribeInstanceStatusResponse DescribeInstanceStatus(DescribeInstanceStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceStatusResponseUnmarshaller.Instance;

            return Invoke<DescribeInstanceStatusResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstanceStatus operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceStatus operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceStatus
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceStatus">REST API Reference for DescribeInstanceStatus Operation</seealso>
        public virtual IAsyncResult BeginDescribeInstanceStatus(DescribeInstanceStatusRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceStatusResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInstanceStatus operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInstanceStatus.</param>
        /// 
        /// <returns>Returns a  DescribeInstanceStatusResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceStatus">REST API Reference for DescribeInstanceStatus Operation</seealso>
        public virtual DescribeInstanceStatusResponse EndDescribeInstanceStatus(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInstanceStatusResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInstanceTypeOfferings

        /// <summary>
        /// Returns a list of all instance types offered. The results can be filtered by location
        /// (Region or Availability Zone). If no location is specified, the instance types offered
        /// in the current Region are returned.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceTypeOfferings service method.</param>
        /// 
        /// <returns>The response from the DescribeInstanceTypeOfferings service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceTypeOfferings">REST API Reference for DescribeInstanceTypeOfferings Operation</seealso>
        public virtual DescribeInstanceTypeOfferingsResponse DescribeInstanceTypeOfferings(DescribeInstanceTypeOfferingsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceTypeOfferingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceTypeOfferingsResponseUnmarshaller.Instance;

            return Invoke<DescribeInstanceTypeOfferingsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstanceTypeOfferings operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceTypeOfferings operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceTypeOfferings
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceTypeOfferings">REST API Reference for DescribeInstanceTypeOfferings Operation</seealso>
        public virtual IAsyncResult BeginDescribeInstanceTypeOfferings(DescribeInstanceTypeOfferingsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceTypeOfferingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceTypeOfferingsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInstanceTypeOfferings operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInstanceTypeOfferings.</param>
        /// 
        /// <returns>Returns a  DescribeInstanceTypeOfferingsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceTypeOfferings">REST API Reference for DescribeInstanceTypeOfferings Operation</seealso>
        public virtual DescribeInstanceTypeOfferingsResponse EndDescribeInstanceTypeOfferings(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInstanceTypeOfferingsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInstanceTypes

        /// <summary>
        /// Describes the details of the instance types that are offered in a location. The results
        /// can be filtered by the attributes of the instance types.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceTypes service method.</param>
        /// 
        /// <returns>The response from the DescribeInstanceTypes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceTypes">REST API Reference for DescribeInstanceTypes Operation</seealso>
        public virtual DescribeInstanceTypesResponse DescribeInstanceTypes(DescribeInstanceTypesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceTypesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceTypesResponseUnmarshaller.Instance;

            return Invoke<DescribeInstanceTypesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInstanceTypes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInstanceTypes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInstanceTypes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceTypes">REST API Reference for DescribeInstanceTypes Operation</seealso>
        public virtual IAsyncResult BeginDescribeInstanceTypes(DescribeInstanceTypesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInstanceTypesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInstanceTypesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInstanceTypes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInstanceTypes.</param>
        /// 
        /// <returns>Returns a  DescribeInstanceTypesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInstanceTypes">REST API Reference for DescribeInstanceTypes Operation</seealso>
        public virtual DescribeInstanceTypesResponse EndDescribeInstanceTypes(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInstanceTypesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeInternetGateways

        /// <summary>
        /// Describes one or more of your internet gateways.
        /// </summary>
        /// 
        /// <returns>The response from the DescribeInternetGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInternetGateways">REST API Reference for DescribeInternetGateways Operation</seealso>
        public virtual DescribeInternetGatewaysResponse DescribeInternetGateways()
        {
            return DescribeInternetGateways(new DescribeInternetGatewaysRequest());
        }

        /// <summary>
        /// Describes one or more of your internet gateways.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeInternetGateways service method.</param>
        /// 
        /// <returns>The response from the DescribeInternetGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInternetGateways">REST API Reference for DescribeInternetGateways Operation</seealso>
        public virtual DescribeInternetGatewaysResponse DescribeInternetGateways(DescribeInternetGatewaysRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInternetGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInternetGatewaysResponseUnmarshaller.Instance;

            return Invoke<DescribeInternetGatewaysResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeInternetGateways operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeInternetGateways operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeInternetGateways
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInternetGateways">REST API Reference for DescribeInternetGateways Operation</seealso>
        public virtual IAsyncResult BeginDescribeInternetGateways(DescribeInternetGatewaysRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeInternetGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeInternetGatewaysResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeInternetGateways operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeInternetGateways.</param>
        /// 
        /// <returns>Returns a  DescribeInternetGatewaysResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeInternetGateways">REST API Reference for DescribeInternetGateways Operation</seealso>
        public virtual DescribeInternetGatewaysResponse EndDescribeInternetGateways(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeInternetGatewaysResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeIpamPools

        /// <summary>
        /// Get information about your IPAM pools.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpamPools service method.</param>
        /// 
        /// <returns>The response from the DescribeIpamPools service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamPools">REST API Reference for DescribeIpamPools Operation</seealso>
        public virtual DescribeIpamPoolsResponse DescribeIpamPools(DescribeIpamPoolsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamPoolsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamPoolsResponseUnmarshaller.Instance;

            return Invoke<DescribeIpamPoolsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeIpamPools operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpamPools operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeIpamPools
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamPools">REST API Reference for DescribeIpamPools Operation</seealso>
        public virtual IAsyncResult BeginDescribeIpamPools(DescribeIpamPoolsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamPoolsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamPoolsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeIpamPools operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeIpamPools.</param>
        /// 
        /// <returns>Returns a  DescribeIpamPoolsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamPools">REST API Reference for DescribeIpamPools Operation</seealso>
        public virtual DescribeIpamPoolsResponse EndDescribeIpamPools(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeIpamPoolsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeIpamResourceDiscoveries

        /// <summary>
        /// Describes IPAM resource discoveries. A resource discovery is an IPAM component that
        /// enables IPAM to manage and monitor resources that belong to the owning account.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpamResourceDiscoveries service method.</param>
        /// 
        /// <returns>The response from the DescribeIpamResourceDiscoveries service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamResourceDiscoveries">REST API Reference for DescribeIpamResourceDiscoveries Operation</seealso>
        public virtual DescribeIpamResourceDiscoveriesResponse DescribeIpamResourceDiscoveries(DescribeIpamResourceDiscoveriesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamResourceDiscoveriesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamResourceDiscoveriesResponseUnmarshaller.Instance;

            return Invoke<DescribeIpamResourceDiscoveriesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeIpamResourceDiscoveries operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpamResourceDiscoveries operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeIpamResourceDiscoveries
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamResourceDiscoveries">REST API Reference for DescribeIpamResourceDiscoveries Operation</seealso>
        public virtual IAsyncResult BeginDescribeIpamResourceDiscoveries(DescribeIpamResourceDiscoveriesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamResourceDiscoveriesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamResourceDiscoveriesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeIpamResourceDiscoveries operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeIpamResourceDiscoveries.</param>
        /// 
        /// <returns>Returns a  DescribeIpamResourceDiscoveriesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamResourceDiscoveries">REST API Reference for DescribeIpamResourceDiscoveries Operation</seealso>
        public virtual DescribeIpamResourceDiscoveriesResponse EndDescribeIpamResourceDiscoveries(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeIpamResourceDiscoveriesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeIpamResourceDiscoveryAssociations

        /// <summary>
        /// Describes resource discovery association with an Amazon VPC IPAM. An associated resource
        /// discovery is a resource discovery that has been associated with an IPAM..
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpamResourceDiscoveryAssociations service method.</param>
        /// 
        /// <returns>The response from the DescribeIpamResourceDiscoveryAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamResourceDiscoveryAssociations">REST API Reference for DescribeIpamResourceDiscoveryAssociations Operation</seealso>
        public virtual DescribeIpamResourceDiscoveryAssociationsResponse DescribeIpamResourceDiscoveryAssociations(DescribeIpamResourceDiscoveryAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamResourceDiscoveryAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamResourceDiscoveryAssociationsResponseUnmarshaller.Instance;

            return Invoke<DescribeIpamResourceDiscoveryAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeIpamResourceDiscoveryAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpamResourceDiscoveryAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeIpamResourceDiscoveryAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamResourceDiscoveryAssociations">REST API Reference for DescribeIpamResourceDiscoveryAssociations Operation</seealso>
        public virtual IAsyncResult BeginDescribeIpamResourceDiscoveryAssociations(DescribeIpamResourceDiscoveryAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamResourceDiscoveryAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamResourceDiscoveryAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeIpamResourceDiscoveryAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeIpamResourceDiscoveryAssociations.</param>
        /// 
        /// <returns>Returns a  DescribeIpamResourceDiscoveryAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamResourceDiscoveryAssociations">REST API Reference for DescribeIpamResourceDiscoveryAssociations Operation</seealso>
        public virtual DescribeIpamResourceDiscoveryAssociationsResponse EndDescribeIpamResourceDiscoveryAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeIpamResourceDiscoveryAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeIpams

        /// <summary>
        /// Get information about your IPAM pools.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/what-is-it-ipam.html">What
        /// is IPAM?</a> in the <i>Amazon VPC IPAM User Guide</i>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpams service method.</param>
        /// 
        /// <returns>The response from the DescribeIpams service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpams">REST API Reference for DescribeIpams Operation</seealso>
        public virtual DescribeIpamsResponse DescribeIpams(DescribeIpamsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamsResponseUnmarshaller.Instance;

            return Invoke<DescribeIpamsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeIpams operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpams operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeIpams
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpams">REST API Reference for DescribeIpams Operation</seealso>
        public virtual IAsyncResult BeginDescribeIpams(DescribeIpamsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeIpams operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeIpams.</param>
        /// 
        /// <returns>Returns a  DescribeIpamsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpams">REST API Reference for DescribeIpams Operation</seealso>
        public virtual DescribeIpamsResponse EndDescribeIpams(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeIpamsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeIpamScopes

        /// <summary>
        /// Get information about your IPAM scopes.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpamScopes service method.</param>
        /// 
        /// <returns>The response from the DescribeIpamScopes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamScopes">REST API Reference for DescribeIpamScopes Operation</seealso>
        public virtual DescribeIpamScopesResponse DescribeIpamScopes(DescribeIpamScopesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamScopesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamScopesResponseUnmarshaller.Instance;

            return Invoke<DescribeIpamScopesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeIpamScopes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpamScopes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeIpamScopes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamScopes">REST API Reference for DescribeIpamScopes Operation</seealso>
        public virtual IAsyncResult BeginDescribeIpamScopes(DescribeIpamScopesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpamScopesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpamScopesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeIpamScopes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeIpamScopes.</param>
        /// 
        /// <returns>Returns a  DescribeIpamScopesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpamScopes">REST API Reference for DescribeIpamScopes Operation</seealso>
        public virtual DescribeIpamScopesResponse EndDescribeIpamScopes(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeIpamScopesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeIpv6Pools

        /// <summary>
        /// Describes your IPv6 address pools.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpv6Pools service method.</param>
        /// 
        /// <returns>The response from the DescribeIpv6Pools service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpv6Pools">REST API Reference for DescribeIpv6Pools Operation</seealso>
        public virtual DescribeIpv6PoolsResponse DescribeIpv6Pools(DescribeIpv6PoolsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpv6PoolsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpv6PoolsResponseUnmarshaller.Instance;

            return Invoke<DescribeIpv6PoolsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeIpv6Pools operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeIpv6Pools operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeIpv6Pools
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpv6Pools">REST API Reference for DescribeIpv6Pools Operation</seealso>
        public virtual IAsyncResult BeginDescribeIpv6Pools(DescribeIpv6PoolsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeIpv6PoolsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeIpv6PoolsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeIpv6Pools operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeIpv6Pools.</param>
        /// 
        /// <returns>Returns a  DescribeIpv6PoolsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeIpv6Pools">REST API Reference for DescribeIpv6Pools Operation</seealso>
        public virtual DescribeIpv6PoolsResponse EndDescribeIpv6Pools(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeIpv6PoolsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeKeyPairs

        /// <summary>
        /// Describes the specified key pairs or all of your key pairs.
        /// 
        ///  
        /// <para>
        /// For more information about key pairs, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Amazon
        /// EC2 key pairs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeKeyPairs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeKeyPairs">REST API Reference for DescribeKeyPairs Operation</seealso>
        public virtual DescribeKeyPairsResponse DescribeKeyPairs()
        {
            return DescribeKeyPairs(new DescribeKeyPairsRequest());
        }

        /// <summary>
        /// Describes the specified key pairs or all of your key pairs.
        /// 
        ///  
        /// <para>
        /// For more information about key pairs, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Amazon
        /// EC2 key pairs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeKeyPairs service method.</param>
        /// 
        /// <returns>The response from the DescribeKeyPairs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeKeyPairs">REST API Reference for DescribeKeyPairs Operation</seealso>
        public virtual DescribeKeyPairsResponse DescribeKeyPairs(DescribeKeyPairsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeKeyPairsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeKeyPairsResponseUnmarshaller.Instance;

            return Invoke<DescribeKeyPairsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeKeyPairs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeKeyPairs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeKeyPairs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeKeyPairs">REST API Reference for DescribeKeyPairs Operation</seealso>
        public virtual IAsyncResult BeginDescribeKeyPairs(DescribeKeyPairsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeKeyPairsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeKeyPairsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeKeyPairs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeKeyPairs.</param>
        /// 
        /// <returns>Returns a  DescribeKeyPairsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeKeyPairs">REST API Reference for DescribeKeyPairs Operation</seealso>
        public virtual DescribeKeyPairsResponse EndDescribeKeyPairs(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeKeyPairsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeLaunchTemplates

        /// <summary>
        /// Describes one or more launch templates.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeLaunchTemplates service method.</param>
        /// 
        /// <returns>The response from the DescribeLaunchTemplates service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLaunchTemplates">REST API Reference for DescribeLaunchTemplates Operation</seealso>
        public virtual DescribeLaunchTemplatesResponse DescribeLaunchTemplates(DescribeLaunchTemplatesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLaunchTemplatesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLaunchTemplatesResponseUnmarshaller.Instance;

            return Invoke<DescribeLaunchTemplatesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeLaunchTemplates operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeLaunchTemplates operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLaunchTemplates
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLaunchTemplates">REST API Reference for DescribeLaunchTemplates Operation</seealso>
        public virtual IAsyncResult BeginDescribeLaunchTemplates(DescribeLaunchTemplatesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLaunchTemplatesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLaunchTemplatesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeLaunchTemplates operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeLaunchTemplates.</param>
        /// 
        /// <returns>Returns a  DescribeLaunchTemplatesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLaunchTemplates">REST API Reference for DescribeLaunchTemplates Operation</seealso>
        public virtual DescribeLaunchTemplatesResponse EndDescribeLaunchTemplates(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeLaunchTemplatesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeLaunchTemplateVersions

        /// <summary>
        /// Describes one or more versions of a specified launch template. You can describe all
        /// versions, individual versions, or a range of versions. You can also describe all the
        /// latest versions or all the default versions of all the launch templates in your account.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeLaunchTemplateVersions service method.</param>
        /// 
        /// <returns>The response from the DescribeLaunchTemplateVersions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLaunchTemplateVersions">REST API Reference for DescribeLaunchTemplateVersions Operation</seealso>
        public virtual DescribeLaunchTemplateVersionsResponse DescribeLaunchTemplateVersions(DescribeLaunchTemplateVersionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLaunchTemplateVersionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLaunchTemplateVersionsResponseUnmarshaller.Instance;

            return Invoke<DescribeLaunchTemplateVersionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeLaunchTemplateVersions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeLaunchTemplateVersions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLaunchTemplateVersions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLaunchTemplateVersions">REST API Reference for DescribeLaunchTemplateVersions Operation</seealso>
        public virtual IAsyncResult BeginDescribeLaunchTemplateVersions(DescribeLaunchTemplateVersionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLaunchTemplateVersionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLaunchTemplateVersionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeLaunchTemplateVersions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeLaunchTemplateVersions.</param>
        /// 
        /// <returns>Returns a  DescribeLaunchTemplateVersionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLaunchTemplateVersions">REST API Reference for DescribeLaunchTemplateVersions Operation</seealso>
        public virtual DescribeLaunchTemplateVersionsResponse EndDescribeLaunchTemplateVersions(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeLaunchTemplateVersionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeLocalGatewayRouteTables

        /// <summary>
        /// Describes one or more local gateway route tables. By default, all local gateway route
        /// tables are described. Alternatively, you can filter the results.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayRouteTables service method.</param>
        /// 
        /// <returns>The response from the DescribeLocalGatewayRouteTables service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTables">REST API Reference for DescribeLocalGatewayRouteTables Operation</seealso>
        public virtual DescribeLocalGatewayRouteTablesResponse DescribeLocalGatewayRouteTables(DescribeLocalGatewayRouteTablesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayRouteTablesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayRouteTablesResponseUnmarshaller.Instance;

            return Invoke<DescribeLocalGatewayRouteTablesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeLocalGatewayRouteTables operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayRouteTables operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLocalGatewayRouteTables
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTables">REST API Reference for DescribeLocalGatewayRouteTables Operation</seealso>
        public virtual IAsyncResult BeginDescribeLocalGatewayRouteTables(DescribeLocalGatewayRouteTablesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayRouteTablesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayRouteTablesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeLocalGatewayRouteTables operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeLocalGatewayRouteTables.</param>
        /// 
        /// <returns>Returns a  DescribeLocalGatewayRouteTablesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTables">REST API Reference for DescribeLocalGatewayRouteTables Operation</seealso>
        public virtual DescribeLocalGatewayRouteTablesResponse EndDescribeLocalGatewayRouteTables(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeLocalGatewayRouteTablesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations

        /// <summary>
        /// Describes the associations between virtual interface groups and local gateway route
        /// tables.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations service method.</param>
        /// 
        /// <returns>The response from the DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations">REST API Reference for DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations Operation</seealso>
        public virtual DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponse DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponseUnmarshaller.Instance;

            return Invoke<DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations">REST API Reference for DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations Operation</seealso>
        public virtual IAsyncResult BeginDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations.</param>
        /// 
        /// <returns>Returns a  DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations">REST API Reference for DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations Operation</seealso>
        public virtual DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponse EndDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeLocalGatewayRouteTableVpcAssociations

        /// <summary>
        /// Describes the specified associations between VPCs and local gateway route tables.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayRouteTableVpcAssociations service method.</param>
        /// 
        /// <returns>The response from the DescribeLocalGatewayRouteTableVpcAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTableVpcAssociations">REST API Reference for DescribeLocalGatewayRouteTableVpcAssociations Operation</seealso>
        public virtual DescribeLocalGatewayRouteTableVpcAssociationsResponse DescribeLocalGatewayRouteTableVpcAssociations(DescribeLocalGatewayRouteTableVpcAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayRouteTableVpcAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayRouteTableVpcAssociationsResponseUnmarshaller.Instance;

            return Invoke<DescribeLocalGatewayRouteTableVpcAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeLocalGatewayRouteTableVpcAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayRouteTableVpcAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLocalGatewayRouteTableVpcAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTableVpcAssociations">REST API Reference for DescribeLocalGatewayRouteTableVpcAssociations Operation</seealso>
        public virtual IAsyncResult BeginDescribeLocalGatewayRouteTableVpcAssociations(DescribeLocalGatewayRouteTableVpcAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayRouteTableVpcAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayRouteTableVpcAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeLocalGatewayRouteTableVpcAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeLocalGatewayRouteTableVpcAssociations.</param>
        /// 
        /// <returns>Returns a  DescribeLocalGatewayRouteTableVpcAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayRouteTableVpcAssociations">REST API Reference for DescribeLocalGatewayRouteTableVpcAssociations Operation</seealso>
        public virtual DescribeLocalGatewayRouteTableVpcAssociationsResponse EndDescribeLocalGatewayRouteTableVpcAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeLocalGatewayRouteTableVpcAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeLocalGateways

        /// <summary>
        /// Describes one or more local gateways. By default, all local gateways are described.
        /// Alternatively, you can filter the results.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGateways service method.</param>
        /// 
        /// <returns>The response from the DescribeLocalGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGateways">REST API Reference for DescribeLocalGateways Operation</seealso>
        public virtual DescribeLocalGatewaysResponse DescribeLocalGateways(DescribeLocalGatewaysRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewaysResponseUnmarshaller.Instance;

            return Invoke<DescribeLocalGatewaysResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeLocalGateways operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGateways operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLocalGateways
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGateways">REST API Reference for DescribeLocalGateways Operation</seealso>
        public virtual IAsyncResult BeginDescribeLocalGateways(DescribeLocalGatewaysRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewaysResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeLocalGateways operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeLocalGateways.</param>
        /// 
        /// <returns>Returns a  DescribeLocalGatewaysResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGateways">REST API Reference for DescribeLocalGateways Operation</seealso>
        public virtual DescribeLocalGatewaysResponse EndDescribeLocalGateways(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeLocalGatewaysResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeLocalGatewayVirtualInterfaceGroups

        /// <summary>
        /// Describes the specified local gateway virtual interface groups.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayVirtualInterfaceGroups service method.</param>
        /// 
        /// <returns>The response from the DescribeLocalGatewayVirtualInterfaceGroups service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayVirtualInterfaceGroups">REST API Reference for DescribeLocalGatewayVirtualInterfaceGroups Operation</seealso>
        public virtual DescribeLocalGatewayVirtualInterfaceGroupsResponse DescribeLocalGatewayVirtualInterfaceGroups(DescribeLocalGatewayVirtualInterfaceGroupsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayVirtualInterfaceGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayVirtualInterfaceGroupsResponseUnmarshaller.Instance;

            return Invoke<DescribeLocalGatewayVirtualInterfaceGroupsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeLocalGatewayVirtualInterfaceGroups operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayVirtualInterfaceGroups operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLocalGatewayVirtualInterfaceGroups
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayVirtualInterfaceGroups">REST API Reference for DescribeLocalGatewayVirtualInterfaceGroups Operation</seealso>
        public virtual IAsyncResult BeginDescribeLocalGatewayVirtualInterfaceGroups(DescribeLocalGatewayVirtualInterfaceGroupsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayVirtualInterfaceGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayVirtualInterfaceGroupsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeLocalGatewayVirtualInterfaceGroups operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeLocalGatewayVirtualInterfaceGroups.</param>
        /// 
        /// <returns>Returns a  DescribeLocalGatewayVirtualInterfaceGroupsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayVirtualInterfaceGroups">REST API Reference for DescribeLocalGatewayVirtualInterfaceGroups Operation</seealso>
        public virtual DescribeLocalGatewayVirtualInterfaceGroupsResponse EndDescribeLocalGatewayVirtualInterfaceGroups(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeLocalGatewayVirtualInterfaceGroupsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeLocalGatewayVirtualInterfaces

        /// <summary>
        /// Describes the specified local gateway virtual interfaces.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayVirtualInterfaces service method.</param>
        /// 
        /// <returns>The response from the DescribeLocalGatewayVirtualInterfaces service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayVirtualInterfaces">REST API Reference for DescribeLocalGatewayVirtualInterfaces Operation</seealso>
        public virtual DescribeLocalGatewayVirtualInterfacesResponse DescribeLocalGatewayVirtualInterfaces(DescribeLocalGatewayVirtualInterfacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayVirtualInterfacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayVirtualInterfacesResponseUnmarshaller.Instance;

            return Invoke<DescribeLocalGatewayVirtualInterfacesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeLocalGatewayVirtualInterfaces operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeLocalGatewayVirtualInterfaces operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLocalGatewayVirtualInterfaces
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayVirtualInterfaces">REST API Reference for DescribeLocalGatewayVirtualInterfaces Operation</seealso>
        public virtual IAsyncResult BeginDescribeLocalGatewayVirtualInterfaces(DescribeLocalGatewayVirtualInterfacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeLocalGatewayVirtualInterfacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeLocalGatewayVirtualInterfacesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeLocalGatewayVirtualInterfaces operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeLocalGatewayVirtualInterfaces.</param>
        /// 
        /// <returns>Returns a  DescribeLocalGatewayVirtualInterfacesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeLocalGatewayVirtualInterfaces">REST API Reference for DescribeLocalGatewayVirtualInterfaces Operation</seealso>
        public virtual DescribeLocalGatewayVirtualInterfacesResponse EndDescribeLocalGatewayVirtualInterfaces(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeLocalGatewayVirtualInterfacesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeManagedPrefixLists

        /// <summary>
        /// Describes your managed prefix lists and any Amazon Web Services-managed prefix lists.
        /// 
        ///  
        /// <para>
        /// To view the entries for your prefix list, use <a>GetManagedPrefixListEntries</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeManagedPrefixLists service method.</param>
        /// 
        /// <returns>The response from the DescribeManagedPrefixLists service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeManagedPrefixLists">REST API Reference for DescribeManagedPrefixLists Operation</seealso>
        public virtual DescribeManagedPrefixListsResponse DescribeManagedPrefixLists(DescribeManagedPrefixListsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeManagedPrefixListsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeManagedPrefixListsResponseUnmarshaller.Instance;

            return Invoke<DescribeManagedPrefixListsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeManagedPrefixLists operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeManagedPrefixLists operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeManagedPrefixLists
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeManagedPrefixLists">REST API Reference for DescribeManagedPrefixLists Operation</seealso>
        public virtual IAsyncResult BeginDescribeManagedPrefixLists(DescribeManagedPrefixListsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeManagedPrefixListsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeManagedPrefixListsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeManagedPrefixLists operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeManagedPrefixLists.</param>
        /// 
        /// <returns>Returns a  DescribeManagedPrefixListsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeManagedPrefixLists">REST API Reference for DescribeManagedPrefixLists Operation</seealso>
        public virtual DescribeManagedPrefixListsResponse EndDescribeManagedPrefixLists(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeManagedPrefixListsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeMovingAddresses

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Describes your Elastic IP addresses that are being moved from or being restored to
        /// the EC2-Classic platform. This request does not return information about any other
        /// Elastic IP addresses in your account.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeMovingAddresses service method.</param>
        /// 
        /// <returns>The response from the DescribeMovingAddresses service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeMovingAddresses">REST API Reference for DescribeMovingAddresses Operation</seealso>
        public virtual DescribeMovingAddressesResponse DescribeMovingAddresses(DescribeMovingAddressesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeMovingAddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeMovingAddressesResponseUnmarshaller.Instance;

            return Invoke<DescribeMovingAddressesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeMovingAddresses operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeMovingAddresses operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeMovingAddresses
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeMovingAddresses">REST API Reference for DescribeMovingAddresses Operation</seealso>
        public virtual IAsyncResult BeginDescribeMovingAddresses(DescribeMovingAddressesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeMovingAddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeMovingAddressesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeMovingAddresses operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeMovingAddresses.</param>
        /// 
        /// <returns>Returns a  DescribeMovingAddressesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeMovingAddresses">REST API Reference for DescribeMovingAddresses Operation</seealso>
        public virtual DescribeMovingAddressesResponse EndDescribeMovingAddresses(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeMovingAddressesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeNatGateways

        /// <summary>
        /// Describes one or more of your NAT gateways.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeNatGateways service method.</param>
        /// 
        /// <returns>The response from the DescribeNatGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNatGateways">REST API Reference for DescribeNatGateways Operation</seealso>
        public virtual DescribeNatGatewaysResponse DescribeNatGateways(DescribeNatGatewaysRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNatGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNatGatewaysResponseUnmarshaller.Instance;

            return Invoke<DescribeNatGatewaysResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeNatGateways operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeNatGateways operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeNatGateways
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNatGateways">REST API Reference for DescribeNatGateways Operation</seealso>
        public virtual IAsyncResult BeginDescribeNatGateways(DescribeNatGatewaysRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNatGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNatGatewaysResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeNatGateways operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeNatGateways.</param>
        /// 
        /// <returns>Returns a  DescribeNatGatewaysResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNatGateways">REST API Reference for DescribeNatGateways Operation</seealso>
        public virtual DescribeNatGatewaysResponse EndDescribeNatGateways(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeNatGatewaysResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeNetworkAcls

        /// <summary>
        /// Describes one or more of your network ACLs.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
        /// ACLs</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeNetworkAcls service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkAcls">REST API Reference for DescribeNetworkAcls Operation</seealso>
        public virtual DescribeNetworkAclsResponse DescribeNetworkAcls()
        {
            return DescribeNetworkAcls(new DescribeNetworkAclsRequest());
        }

        /// <summary>
        /// Describes one or more of your network ACLs.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
        /// ACLs</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkAcls service method.</param>
        /// 
        /// <returns>The response from the DescribeNetworkAcls service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkAcls">REST API Reference for DescribeNetworkAcls Operation</seealso>
        public virtual DescribeNetworkAclsResponse DescribeNetworkAcls(DescribeNetworkAclsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkAclsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkAclsResponseUnmarshaller.Instance;

            return Invoke<DescribeNetworkAclsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeNetworkAcls operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkAcls operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeNetworkAcls
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkAcls">REST API Reference for DescribeNetworkAcls Operation</seealso>
        public virtual IAsyncResult BeginDescribeNetworkAcls(DescribeNetworkAclsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkAclsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkAclsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeNetworkAcls operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeNetworkAcls.</param>
        /// 
        /// <returns>Returns a  DescribeNetworkAclsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkAcls">REST API Reference for DescribeNetworkAcls Operation</seealso>
        public virtual DescribeNetworkAclsResponse EndDescribeNetworkAcls(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeNetworkAclsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeNetworkInsightsAccessScopeAnalyses

        /// <summary>
        /// Describes the specified Network Access Scope analyses.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInsightsAccessScopeAnalyses service method.</param>
        /// 
        /// <returns>The response from the DescribeNetworkInsightsAccessScopeAnalyses service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAccessScopeAnalyses">REST API Reference for DescribeNetworkInsightsAccessScopeAnalyses Operation</seealso>
        public virtual DescribeNetworkInsightsAccessScopeAnalysesResponse DescribeNetworkInsightsAccessScopeAnalyses(DescribeNetworkInsightsAccessScopeAnalysesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInsightsAccessScopeAnalysesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInsightsAccessScopeAnalysesResponseUnmarshaller.Instance;

            return Invoke<DescribeNetworkInsightsAccessScopeAnalysesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeNetworkInsightsAccessScopeAnalyses operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInsightsAccessScopeAnalyses operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeNetworkInsightsAccessScopeAnalyses
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAccessScopeAnalyses">REST API Reference for DescribeNetworkInsightsAccessScopeAnalyses Operation</seealso>
        public virtual IAsyncResult BeginDescribeNetworkInsightsAccessScopeAnalyses(DescribeNetworkInsightsAccessScopeAnalysesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInsightsAccessScopeAnalysesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInsightsAccessScopeAnalysesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeNetworkInsightsAccessScopeAnalyses operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeNetworkInsightsAccessScopeAnalyses.</param>
        /// 
        /// <returns>Returns a  DescribeNetworkInsightsAccessScopeAnalysesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAccessScopeAnalyses">REST API Reference for DescribeNetworkInsightsAccessScopeAnalyses Operation</seealso>
        public virtual DescribeNetworkInsightsAccessScopeAnalysesResponse EndDescribeNetworkInsightsAccessScopeAnalyses(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeNetworkInsightsAccessScopeAnalysesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeNetworkInsightsAccessScopes

        /// <summary>
        /// Describes the specified Network Access Scopes.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInsightsAccessScopes service method.</param>
        /// 
        /// <returns>The response from the DescribeNetworkInsightsAccessScopes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAccessScopes">REST API Reference for DescribeNetworkInsightsAccessScopes Operation</seealso>
        public virtual DescribeNetworkInsightsAccessScopesResponse DescribeNetworkInsightsAccessScopes(DescribeNetworkInsightsAccessScopesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInsightsAccessScopesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInsightsAccessScopesResponseUnmarshaller.Instance;

            return Invoke<DescribeNetworkInsightsAccessScopesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeNetworkInsightsAccessScopes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInsightsAccessScopes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeNetworkInsightsAccessScopes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAccessScopes">REST API Reference for DescribeNetworkInsightsAccessScopes Operation</seealso>
        public virtual IAsyncResult BeginDescribeNetworkInsightsAccessScopes(DescribeNetworkInsightsAccessScopesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInsightsAccessScopesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInsightsAccessScopesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeNetworkInsightsAccessScopes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeNetworkInsightsAccessScopes.</param>
        /// 
        /// <returns>Returns a  DescribeNetworkInsightsAccessScopesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAccessScopes">REST API Reference for DescribeNetworkInsightsAccessScopes Operation</seealso>
        public virtual DescribeNetworkInsightsAccessScopesResponse EndDescribeNetworkInsightsAccessScopes(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeNetworkInsightsAccessScopesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeNetworkInsightsAnalyses

        /// <summary>
        /// Describes one or more of your network insights analyses.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInsightsAnalyses service method.</param>
        /// 
        /// <returns>The response from the DescribeNetworkInsightsAnalyses service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAnalyses">REST API Reference for DescribeNetworkInsightsAnalyses Operation</seealso>
        public virtual DescribeNetworkInsightsAnalysesResponse DescribeNetworkInsightsAnalyses(DescribeNetworkInsightsAnalysesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInsightsAnalysesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInsightsAnalysesResponseUnmarshaller.Instance;

            return Invoke<DescribeNetworkInsightsAnalysesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeNetworkInsightsAnalyses operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInsightsAnalyses operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeNetworkInsightsAnalyses
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAnalyses">REST API Reference for DescribeNetworkInsightsAnalyses Operation</seealso>
        public virtual IAsyncResult BeginDescribeNetworkInsightsAnalyses(DescribeNetworkInsightsAnalysesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInsightsAnalysesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInsightsAnalysesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeNetworkInsightsAnalyses operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeNetworkInsightsAnalyses.</param>
        /// 
        /// <returns>Returns a  DescribeNetworkInsightsAnalysesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsAnalyses">REST API Reference for DescribeNetworkInsightsAnalyses Operation</seealso>
        public virtual DescribeNetworkInsightsAnalysesResponse EndDescribeNetworkInsightsAnalyses(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeNetworkInsightsAnalysesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeNetworkInsightsPaths

        /// <summary>
        /// Describes one or more of your paths.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInsightsPaths service method.</param>
        /// 
        /// <returns>The response from the DescribeNetworkInsightsPaths service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsPaths">REST API Reference for DescribeNetworkInsightsPaths Operation</seealso>
        public virtual DescribeNetworkInsightsPathsResponse DescribeNetworkInsightsPaths(DescribeNetworkInsightsPathsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInsightsPathsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInsightsPathsResponseUnmarshaller.Instance;

            return Invoke<DescribeNetworkInsightsPathsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeNetworkInsightsPaths operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInsightsPaths operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeNetworkInsightsPaths
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsPaths">REST API Reference for DescribeNetworkInsightsPaths Operation</seealso>
        public virtual IAsyncResult BeginDescribeNetworkInsightsPaths(DescribeNetworkInsightsPathsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInsightsPathsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInsightsPathsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeNetworkInsightsPaths operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeNetworkInsightsPaths.</param>
        /// 
        /// <returns>Returns a  DescribeNetworkInsightsPathsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInsightsPaths">REST API Reference for DescribeNetworkInsightsPaths Operation</seealso>
        public virtual DescribeNetworkInsightsPathsResponse EndDescribeNetworkInsightsPaths(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeNetworkInsightsPathsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeNetworkInterfaceAttribute

        /// <summary>
        /// Describes a network interface attribute. You can specify only one attribute at a time.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInterfaceAttribute service method.</param>
        /// 
        /// <returns>The response from the DescribeNetworkInterfaceAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfaceAttribute">REST API Reference for DescribeNetworkInterfaceAttribute Operation</seealso>
        public virtual DescribeNetworkInterfaceAttributeResponse DescribeNetworkInterfaceAttribute(DescribeNetworkInterfaceAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInterfaceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInterfaceAttributeResponseUnmarshaller.Instance;

            return Invoke<DescribeNetworkInterfaceAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeNetworkInterfaceAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInterfaceAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeNetworkInterfaceAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfaceAttribute">REST API Reference for DescribeNetworkInterfaceAttribute Operation</seealso>
        public virtual IAsyncResult BeginDescribeNetworkInterfaceAttribute(DescribeNetworkInterfaceAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInterfaceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInterfaceAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeNetworkInterfaceAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeNetworkInterfaceAttribute.</param>
        /// 
        /// <returns>Returns a  DescribeNetworkInterfaceAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfaceAttribute">REST API Reference for DescribeNetworkInterfaceAttribute Operation</seealso>
        public virtual DescribeNetworkInterfaceAttributeResponse EndDescribeNetworkInterfaceAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeNetworkInterfaceAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeNetworkInterfacePermissions

        /// <summary>
        /// Describes the permissions for your network interfaces.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInterfacePermissions service method.</param>
        /// 
        /// <returns>The response from the DescribeNetworkInterfacePermissions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfacePermissions">REST API Reference for DescribeNetworkInterfacePermissions Operation</seealso>
        public virtual DescribeNetworkInterfacePermissionsResponse DescribeNetworkInterfacePermissions(DescribeNetworkInterfacePermissionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInterfacePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInterfacePermissionsResponseUnmarshaller.Instance;

            return Invoke<DescribeNetworkInterfacePermissionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeNetworkInterfacePermissions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInterfacePermissions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeNetworkInterfacePermissions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfacePermissions">REST API Reference for DescribeNetworkInterfacePermissions Operation</seealso>
        public virtual IAsyncResult BeginDescribeNetworkInterfacePermissions(DescribeNetworkInterfacePermissionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInterfacePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInterfacePermissionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeNetworkInterfacePermissions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeNetworkInterfacePermissions.</param>
        /// 
        /// <returns>Returns a  DescribeNetworkInterfacePermissionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfacePermissions">REST API Reference for DescribeNetworkInterfacePermissions Operation</seealso>
        public virtual DescribeNetworkInterfacePermissionsResponse EndDescribeNetworkInterfacePermissions(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeNetworkInterfacePermissionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeNetworkInterfaces

        /// <summary>
        /// Describes one or more of your network interfaces.
        /// </summary>
        /// 
        /// <returns>The response from the DescribeNetworkInterfaces service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfaces">REST API Reference for DescribeNetworkInterfaces Operation</seealso>
        public virtual DescribeNetworkInterfacesResponse DescribeNetworkInterfaces()
        {
            return DescribeNetworkInterfaces(new DescribeNetworkInterfacesRequest());
        }

        /// <summary>
        /// Describes one or more of your network interfaces.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInterfaces service method.</param>
        /// 
        /// <returns>The response from the DescribeNetworkInterfaces service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfaces">REST API Reference for DescribeNetworkInterfaces Operation</seealso>
        public virtual DescribeNetworkInterfacesResponse DescribeNetworkInterfaces(DescribeNetworkInterfacesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInterfacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInterfacesResponseUnmarshaller.Instance;

            return Invoke<DescribeNetworkInterfacesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeNetworkInterfaces operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeNetworkInterfaces operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeNetworkInterfaces
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfaces">REST API Reference for DescribeNetworkInterfaces Operation</seealso>
        public virtual IAsyncResult BeginDescribeNetworkInterfaces(DescribeNetworkInterfacesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeNetworkInterfacesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeNetworkInterfacesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeNetworkInterfaces operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeNetworkInterfaces.</param>
        /// 
        /// <returns>Returns a  DescribeNetworkInterfacesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeNetworkInterfaces">REST API Reference for DescribeNetworkInterfaces Operation</seealso>
        public virtual DescribeNetworkInterfacesResponse EndDescribeNetworkInterfaces(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeNetworkInterfacesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribePlacementGroups

        /// <summary>
        /// Describes the specified placement groups or all of your placement groups. For more
        /// information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">Placement
        /// groups</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// 
        /// <returns>The response from the DescribePlacementGroups service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePlacementGroups">REST API Reference for DescribePlacementGroups Operation</seealso>
        public virtual DescribePlacementGroupsResponse DescribePlacementGroups()
        {
            return DescribePlacementGroups(new DescribePlacementGroupsRequest());
        }

        /// <summary>
        /// Describes the specified placement groups or all of your placement groups. For more
        /// information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">Placement
        /// groups</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribePlacementGroups service method.</param>
        /// 
        /// <returns>The response from the DescribePlacementGroups service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePlacementGroups">REST API Reference for DescribePlacementGroups Operation</seealso>
        public virtual DescribePlacementGroupsResponse DescribePlacementGroups(DescribePlacementGroupsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribePlacementGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribePlacementGroupsResponseUnmarshaller.Instance;

            return Invoke<DescribePlacementGroupsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribePlacementGroups operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribePlacementGroups operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribePlacementGroups
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePlacementGroups">REST API Reference for DescribePlacementGroups Operation</seealso>
        public virtual IAsyncResult BeginDescribePlacementGroups(DescribePlacementGroupsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribePlacementGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribePlacementGroupsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribePlacementGroups operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribePlacementGroups.</param>
        /// 
        /// <returns>Returns a  DescribePlacementGroupsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePlacementGroups">REST API Reference for DescribePlacementGroups Operation</seealso>
        public virtual DescribePlacementGroupsResponse EndDescribePlacementGroups(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribePlacementGroupsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribePrefixLists

        /// <summary>
        /// Describes available Amazon Web Services services in a prefix list format, which includes
        /// the prefix list name and prefix list ID of the service and the IP address range for
        /// the service.
        /// 
        ///  
        /// <para>
        /// We recommend that you use <a>DescribeManagedPrefixLists</a> instead.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribePrefixLists service method.</param>
        /// 
        /// <returns>The response from the DescribePrefixLists service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePrefixLists">REST API Reference for DescribePrefixLists Operation</seealso>
        public virtual DescribePrefixListsResponse DescribePrefixLists(DescribePrefixListsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribePrefixListsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribePrefixListsResponseUnmarshaller.Instance;

            return Invoke<DescribePrefixListsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribePrefixLists operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribePrefixLists operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribePrefixLists
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePrefixLists">REST API Reference for DescribePrefixLists Operation</seealso>
        public virtual IAsyncResult BeginDescribePrefixLists(DescribePrefixListsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribePrefixListsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribePrefixListsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribePrefixLists operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribePrefixLists.</param>
        /// 
        /// <returns>Returns a  DescribePrefixListsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePrefixLists">REST API Reference for DescribePrefixLists Operation</seealso>
        public virtual DescribePrefixListsResponse EndDescribePrefixLists(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribePrefixListsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribePrincipalIdFormat

        /// <summary>
        /// Describes the ID format settings for the root user and all IAM roles and IAM users
        /// that have explicitly specified a longer ID (17-character ID) preference. 
        /// 
        ///  
        /// <para>
        /// By default, all IAM roles and IAM users default to the same ID settings as the root
        /// user, unless they explicitly override the settings. This request is useful for identifying
        /// those IAM users and IAM roles that have overridden the default ID settings.
        /// </para>
        ///  
        /// <para>
        /// The following resource types support longer IDs: <code>bundle</code> | <code>conversion-task</code>
        /// | <code>customer-gateway</code> | <code>dhcp-options</code> | <code>elastic-ip-allocation</code>
        /// | <code>elastic-ip-association</code> | <code>export-task</code> | <code>flow-log</code>
        /// | <code>image</code> | <code>import-task</code> | <code>instance</code> | <code>internet-gateway</code>
        /// | <code>network-acl</code> | <code>network-acl-association</code> | <code>network-interface</code>
        /// | <code>network-interface-attachment</code> | <code>prefix-list</code> | <code>reservation</code>
        /// | <code>route-table</code> | <code>route-table-association</code> | <code>security-group</code>
        /// | <code>snapshot</code> | <code>subnet</code> | <code>subnet-cidr-block-association</code>
        /// | <code>volume</code> | <code>vpc</code> | <code>vpc-cidr-block-association</code>
        /// | <code>vpc-endpoint</code> | <code>vpc-peering-connection</code> | <code>vpn-connection</code>
        /// | <code>vpn-gateway</code>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribePrincipalIdFormat service method.</param>
        /// 
        /// <returns>The response from the DescribePrincipalIdFormat service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePrincipalIdFormat">REST API Reference for DescribePrincipalIdFormat Operation</seealso>
        public virtual DescribePrincipalIdFormatResponse DescribePrincipalIdFormat(DescribePrincipalIdFormatRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribePrincipalIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribePrincipalIdFormatResponseUnmarshaller.Instance;

            return Invoke<DescribePrincipalIdFormatResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribePrincipalIdFormat operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribePrincipalIdFormat operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribePrincipalIdFormat
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePrincipalIdFormat">REST API Reference for DescribePrincipalIdFormat Operation</seealso>
        public virtual IAsyncResult BeginDescribePrincipalIdFormat(DescribePrincipalIdFormatRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribePrincipalIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribePrincipalIdFormatResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribePrincipalIdFormat operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribePrincipalIdFormat.</param>
        /// 
        /// <returns>Returns a  DescribePrincipalIdFormatResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePrincipalIdFormat">REST API Reference for DescribePrincipalIdFormat Operation</seealso>
        public virtual DescribePrincipalIdFormatResponse EndDescribePrincipalIdFormat(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribePrincipalIdFormatResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribePublicIpv4Pools

        /// <summary>
        /// Describes the specified IPv4 address pools.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribePublicIpv4Pools service method.</param>
        /// 
        /// <returns>The response from the DescribePublicIpv4Pools service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePublicIpv4Pools">REST API Reference for DescribePublicIpv4Pools Operation</seealso>
        public virtual DescribePublicIpv4PoolsResponse DescribePublicIpv4Pools(DescribePublicIpv4PoolsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribePublicIpv4PoolsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribePublicIpv4PoolsResponseUnmarshaller.Instance;

            return Invoke<DescribePublicIpv4PoolsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribePublicIpv4Pools operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribePublicIpv4Pools operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribePublicIpv4Pools
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePublicIpv4Pools">REST API Reference for DescribePublicIpv4Pools Operation</seealso>
        public virtual IAsyncResult BeginDescribePublicIpv4Pools(DescribePublicIpv4PoolsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribePublicIpv4PoolsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribePublicIpv4PoolsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribePublicIpv4Pools operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribePublicIpv4Pools.</param>
        /// 
        /// <returns>Returns a  DescribePublicIpv4PoolsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribePublicIpv4Pools">REST API Reference for DescribePublicIpv4Pools Operation</seealso>
        public virtual DescribePublicIpv4PoolsResponse EndDescribePublicIpv4Pools(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribePublicIpv4PoolsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeRegions

        /// <summary>
        /// Describes the Regions that are enabled for your account, or all Regions.
        /// 
        ///  
        /// <para>
        /// For a list of the Regions supported by Amazon EC2, see <a href="https://docs.aws.amazon.com/general/latest/gr/ec2-service.html">
        /// Amazon Elastic Compute Cloud endpoints and quotas</a>.
        /// </para>
        ///  
        /// <para>
        /// For information about enabling and disabling Regions for your account, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande-manage.html">Managing
        /// Amazon Web Services Regions</a> in the <i>Amazon Web Services General Reference</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeRegions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRegions">REST API Reference for DescribeRegions Operation</seealso>
        public virtual DescribeRegionsResponse DescribeRegions()
        {
            return DescribeRegions(new DescribeRegionsRequest());
        }

        /// <summary>
        /// Describes the Regions that are enabled for your account, or all Regions.
        /// 
        ///  
        /// <para>
        /// For a list of the Regions supported by Amazon EC2, see <a href="https://docs.aws.amazon.com/general/latest/gr/ec2-service.html">
        /// Amazon Elastic Compute Cloud endpoints and quotas</a>.
        /// </para>
        ///  
        /// <para>
        /// For information about enabling and disabling Regions for your account, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande-manage.html">Managing
        /// Amazon Web Services Regions</a> in the <i>Amazon Web Services General Reference</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeRegions service method.</param>
        /// 
        /// <returns>The response from the DescribeRegions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRegions">REST API Reference for DescribeRegions Operation</seealso>
        public virtual DescribeRegionsResponse DescribeRegions(DescribeRegionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeRegionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeRegionsResponseUnmarshaller.Instance;

            return Invoke<DescribeRegionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeRegions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeRegions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeRegions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRegions">REST API Reference for DescribeRegions Operation</seealso>
        public virtual IAsyncResult BeginDescribeRegions(DescribeRegionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeRegionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeRegionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeRegions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeRegions.</param>
        /// 
        /// <returns>Returns a  DescribeRegionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRegions">REST API Reference for DescribeRegions Operation</seealso>
        public virtual DescribeRegionsResponse EndDescribeRegions(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeRegionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeReplaceRootVolumeTasks

        /// <summary>
        /// Describes a root volume replacement task. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/replace-root.html">Replace
        /// a root volume</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeReplaceRootVolumeTasks service method.</param>
        /// 
        /// <returns>The response from the DescribeReplaceRootVolumeTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReplaceRootVolumeTasks">REST API Reference for DescribeReplaceRootVolumeTasks Operation</seealso>
        public virtual DescribeReplaceRootVolumeTasksResponse DescribeReplaceRootVolumeTasks(DescribeReplaceRootVolumeTasksRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReplaceRootVolumeTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReplaceRootVolumeTasksResponseUnmarshaller.Instance;

            return Invoke<DescribeReplaceRootVolumeTasksResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeReplaceRootVolumeTasks operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeReplaceRootVolumeTasks operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeReplaceRootVolumeTasks
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReplaceRootVolumeTasks">REST API Reference for DescribeReplaceRootVolumeTasks Operation</seealso>
        public virtual IAsyncResult BeginDescribeReplaceRootVolumeTasks(DescribeReplaceRootVolumeTasksRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReplaceRootVolumeTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReplaceRootVolumeTasksResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeReplaceRootVolumeTasks operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeReplaceRootVolumeTasks.</param>
        /// 
        /// <returns>Returns a  DescribeReplaceRootVolumeTasksResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReplaceRootVolumeTasks">REST API Reference for DescribeReplaceRootVolumeTasks Operation</seealso>
        public virtual DescribeReplaceRootVolumeTasksResponse EndDescribeReplaceRootVolumeTasks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeReplaceRootVolumeTasksResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeReservedInstances

        /// <summary>
        /// Describes one or more of the Reserved Instances that you purchased.
        /// 
        ///  
        /// <para>
        /// For more information about Reserved Instances, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts-on-demand-reserved-instances.html">Reserved
        /// Instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeReservedInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstances">REST API Reference for DescribeReservedInstances Operation</seealso>
        public virtual DescribeReservedInstancesResponse DescribeReservedInstances()
        {
            return DescribeReservedInstances(new DescribeReservedInstancesRequest());
        }

        /// <summary>
        /// Describes one or more of the Reserved Instances that you purchased.
        /// 
        ///  
        /// <para>
        /// For more information about Reserved Instances, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts-on-demand-reserved-instances.html">Reserved
        /// Instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeReservedInstances service method.</param>
        /// 
        /// <returns>The response from the DescribeReservedInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstances">REST API Reference for DescribeReservedInstances Operation</seealso>
        public virtual DescribeReservedInstancesResponse DescribeReservedInstances(DescribeReservedInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReservedInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReservedInstancesResponseUnmarshaller.Instance;

            return Invoke<DescribeReservedInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeReservedInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeReservedInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeReservedInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstances">REST API Reference for DescribeReservedInstances Operation</seealso>
        public virtual IAsyncResult BeginDescribeReservedInstances(DescribeReservedInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReservedInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReservedInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeReservedInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeReservedInstances.</param>
        /// 
        /// <returns>Returns a  DescribeReservedInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstances">REST API Reference for DescribeReservedInstances Operation</seealso>
        public virtual DescribeReservedInstancesResponse EndDescribeReservedInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeReservedInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeReservedInstancesListings

        /// <summary>
        /// Describes your account's Reserved Instance listings in the Reserved Instance Marketplace.
        /// 
        ///  
        /// <para>
        /// The Reserved Instance Marketplace matches sellers who want to resell Reserved Instance
        /// capacity that they no longer need with buyers who want to purchase additional capacity.
        /// Reserved Instances bought and sold through the Reserved Instance Marketplace work
        /// like any other Reserved Instances.
        /// </para>
        ///  
        /// <para>
        /// As a seller, you choose to list some or all of your Reserved Instances, and you specify
        /// the upfront price to receive for them. Your Reserved Instances are then listed in
        /// the Reserved Instance Marketplace and are available for purchase.
        /// </para>
        ///  
        /// <para>
        /// As a buyer, you specify the configuration of the Reserved Instance to purchase, and
        /// the Marketplace matches what you're searching for with what's available. The Marketplace
        /// first sells the lowest priced Reserved Instances to you, and continues to sell available
        /// Reserved Instance listings to you until your demand is met. You are charged based
        /// on the total price of all of the listings that you purchase.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Reserved
        /// Instance Marketplace</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeReservedInstancesListings service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesListings">REST API Reference for DescribeReservedInstancesListings Operation</seealso>
        public virtual DescribeReservedInstancesListingsResponse DescribeReservedInstancesListings()
        {
            return DescribeReservedInstancesListings(new DescribeReservedInstancesListingsRequest());
        }

        /// <summary>
        /// Describes your account's Reserved Instance listings in the Reserved Instance Marketplace.
        /// 
        ///  
        /// <para>
        /// The Reserved Instance Marketplace matches sellers who want to resell Reserved Instance
        /// capacity that they no longer need with buyers who want to purchase additional capacity.
        /// Reserved Instances bought and sold through the Reserved Instance Marketplace work
        /// like any other Reserved Instances.
        /// </para>
        ///  
        /// <para>
        /// As a seller, you choose to list some or all of your Reserved Instances, and you specify
        /// the upfront price to receive for them. Your Reserved Instances are then listed in
        /// the Reserved Instance Marketplace and are available for purchase.
        /// </para>
        ///  
        /// <para>
        /// As a buyer, you specify the configuration of the Reserved Instance to purchase, and
        /// the Marketplace matches what you're searching for with what's available. The Marketplace
        /// first sells the lowest priced Reserved Instances to you, and continues to sell available
        /// Reserved Instance listings to you until your demand is met. You are charged based
        /// on the total price of all of the listings that you purchase.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Reserved
        /// Instance Marketplace</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeReservedInstancesListings service method.</param>
        /// 
        /// <returns>The response from the DescribeReservedInstancesListings service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesListings">REST API Reference for DescribeReservedInstancesListings Operation</seealso>
        public virtual DescribeReservedInstancesListingsResponse DescribeReservedInstancesListings(DescribeReservedInstancesListingsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReservedInstancesListingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReservedInstancesListingsResponseUnmarshaller.Instance;

            return Invoke<DescribeReservedInstancesListingsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeReservedInstancesListings operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeReservedInstancesListings operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeReservedInstancesListings
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesListings">REST API Reference for DescribeReservedInstancesListings Operation</seealso>
        public virtual IAsyncResult BeginDescribeReservedInstancesListings(DescribeReservedInstancesListingsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReservedInstancesListingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReservedInstancesListingsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeReservedInstancesListings operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeReservedInstancesListings.</param>
        /// 
        /// <returns>Returns a  DescribeReservedInstancesListingsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesListings">REST API Reference for DescribeReservedInstancesListings Operation</seealso>
        public virtual DescribeReservedInstancesListingsResponse EndDescribeReservedInstancesListings(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeReservedInstancesListingsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeReservedInstancesModifications

        /// <summary>
        /// Describes the modifications made to your Reserved Instances. If no parameter is specified,
        /// information about all your Reserved Instances modification requests is returned. If
        /// a modification ID is specified, only information about the specific modification is
        /// returned.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-modifying.html">Modifying
        /// Reserved Instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeReservedInstancesModifications service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesModifications">REST API Reference for DescribeReservedInstancesModifications Operation</seealso>
        public virtual DescribeReservedInstancesModificationsResponse DescribeReservedInstancesModifications()
        {
            return DescribeReservedInstancesModifications(new DescribeReservedInstancesModificationsRequest());
        }

        /// <summary>
        /// Describes the modifications made to your Reserved Instances. If no parameter is specified,
        /// information about all your Reserved Instances modification requests is returned. If
        /// a modification ID is specified, only information about the specific modification is
        /// returned.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-modifying.html">Modifying
        /// Reserved Instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeReservedInstancesModifications service method.</param>
        /// 
        /// <returns>The response from the DescribeReservedInstancesModifications service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesModifications">REST API Reference for DescribeReservedInstancesModifications Operation</seealso>
        public virtual DescribeReservedInstancesModificationsResponse DescribeReservedInstancesModifications(DescribeReservedInstancesModificationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReservedInstancesModificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReservedInstancesModificationsResponseUnmarshaller.Instance;

            return Invoke<DescribeReservedInstancesModificationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeReservedInstancesModifications operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeReservedInstancesModifications operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeReservedInstancesModifications
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesModifications">REST API Reference for DescribeReservedInstancesModifications Operation</seealso>
        public virtual IAsyncResult BeginDescribeReservedInstancesModifications(DescribeReservedInstancesModificationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReservedInstancesModificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReservedInstancesModificationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeReservedInstancesModifications operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeReservedInstancesModifications.</param>
        /// 
        /// <returns>Returns a  DescribeReservedInstancesModificationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesModifications">REST API Reference for DescribeReservedInstancesModifications Operation</seealso>
        public virtual DescribeReservedInstancesModificationsResponse EndDescribeReservedInstancesModifications(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeReservedInstancesModificationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeReservedInstancesOfferings

        /// <summary>
        /// Describes Reserved Instance offerings that are available for purchase. With Reserved
        /// Instances, you purchase the right to launch instances for a period of time. During
        /// that time period, you do not receive insufficient capacity errors, and you pay a lower
        /// usage rate than the rate charged for On-Demand instances for the actual time used.
        /// 
        ///  
        /// <para>
        /// If you have listed your own Reserved Instances for sale in the Reserved Instance Marketplace,
        /// they will be excluded from these results. This is to ensure that you do not purchase
        /// your own Reserved Instances.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Reserved
        /// Instance Marketplace</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeReservedInstancesOfferings service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesOfferings">REST API Reference for DescribeReservedInstancesOfferings Operation</seealso>
        public virtual DescribeReservedInstancesOfferingsResponse DescribeReservedInstancesOfferings()
        {
            return DescribeReservedInstancesOfferings(new DescribeReservedInstancesOfferingsRequest());
        }

        /// <summary>
        /// Describes Reserved Instance offerings that are available for purchase. With Reserved
        /// Instances, you purchase the right to launch instances for a period of time. During
        /// that time period, you do not receive insufficient capacity errors, and you pay a lower
        /// usage rate than the rate charged for On-Demand instances for the actual time used.
        /// 
        ///  
        /// <para>
        /// If you have listed your own Reserved Instances for sale in the Reserved Instance Marketplace,
        /// they will be excluded from these results. This is to ensure that you do not purchase
        /// your own Reserved Instances.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Reserved
        /// Instance Marketplace</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeReservedInstancesOfferings service method.</param>
        /// 
        /// <returns>The response from the DescribeReservedInstancesOfferings service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesOfferings">REST API Reference for DescribeReservedInstancesOfferings Operation</seealso>
        public virtual DescribeReservedInstancesOfferingsResponse DescribeReservedInstancesOfferings(DescribeReservedInstancesOfferingsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReservedInstancesOfferingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReservedInstancesOfferingsResponseUnmarshaller.Instance;

            return Invoke<DescribeReservedInstancesOfferingsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeReservedInstancesOfferings operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeReservedInstancesOfferings operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeReservedInstancesOfferings
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesOfferings">REST API Reference for DescribeReservedInstancesOfferings Operation</seealso>
        public virtual IAsyncResult BeginDescribeReservedInstancesOfferings(DescribeReservedInstancesOfferingsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeReservedInstancesOfferingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeReservedInstancesOfferingsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeReservedInstancesOfferings operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeReservedInstancesOfferings.</param>
        /// 
        /// <returns>Returns a  DescribeReservedInstancesOfferingsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeReservedInstancesOfferings">REST API Reference for DescribeReservedInstancesOfferings Operation</seealso>
        public virtual DescribeReservedInstancesOfferingsResponse EndDescribeReservedInstancesOfferings(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeReservedInstancesOfferingsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeRouteTables

        /// <summary>
        /// Describes one or more of your route tables.
        /// 
        ///  
        /// <para>
        /// Each subnet in your VPC must be associated with a route table. If a subnet is not
        /// explicitly associated with any route table, it is implicitly associated with the main
        /// route table. This command does not return the subnet ID for implicit associations.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
        /// tables</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeRouteTables service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRouteTables">REST API Reference for DescribeRouteTables Operation</seealso>
        public virtual DescribeRouteTablesResponse DescribeRouteTables()
        {
            return DescribeRouteTables(new DescribeRouteTablesRequest());
        }

        /// <summary>
        /// Describes one or more of your route tables.
        /// 
        ///  
        /// <para>
        /// Each subnet in your VPC must be associated with a route table. If a subnet is not
        /// explicitly associated with any route table, it is implicitly associated with the main
        /// route table. This command does not return the subnet ID for implicit associations.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
        /// tables</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeRouteTables service method.</param>
        /// 
        /// <returns>The response from the DescribeRouteTables service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRouteTables">REST API Reference for DescribeRouteTables Operation</seealso>
        public virtual DescribeRouteTablesResponse DescribeRouteTables(DescribeRouteTablesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeRouteTablesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeRouteTablesResponseUnmarshaller.Instance;

            return Invoke<DescribeRouteTablesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeRouteTables operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeRouteTables operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeRouteTables
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRouteTables">REST API Reference for DescribeRouteTables Operation</seealso>
        public virtual IAsyncResult BeginDescribeRouteTables(DescribeRouteTablesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeRouteTablesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeRouteTablesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeRouteTables operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeRouteTables.</param>
        /// 
        /// <returns>Returns a  DescribeRouteTablesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeRouteTables">REST API Reference for DescribeRouteTables Operation</seealso>
        public virtual DescribeRouteTablesResponse EndDescribeRouteTables(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeRouteTablesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeScheduledInstanceAvailability

        /// <summary>
        /// Finds available schedules that meet the specified criteria.
        /// 
        ///  
        /// <para>
        /// You can search for an available schedule no more than 3 months in advance. You must
        /// meet the minimum required duration of 1,200 hours per year. For example, the minimum
        /// daily schedule is 4 hours, the minimum weekly schedule is 24 hours, and the minimum
        /// monthly schedule is 100 hours.
        /// </para>
        ///  
        /// <para>
        /// After you find a schedule that meets your needs, call <a>PurchaseScheduledInstances</a>
        /// to purchase Scheduled Instances with that schedule.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeScheduledInstanceAvailability service method.</param>
        /// 
        /// <returns>The response from the DescribeScheduledInstanceAvailability service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeScheduledInstanceAvailability">REST API Reference for DescribeScheduledInstanceAvailability Operation</seealso>
        public virtual DescribeScheduledInstanceAvailabilityResponse DescribeScheduledInstanceAvailability(DescribeScheduledInstanceAvailabilityRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeScheduledInstanceAvailabilityRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeScheduledInstanceAvailabilityResponseUnmarshaller.Instance;

            return Invoke<DescribeScheduledInstanceAvailabilityResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeScheduledInstanceAvailability operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeScheduledInstanceAvailability operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeScheduledInstanceAvailability
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeScheduledInstanceAvailability">REST API Reference for DescribeScheduledInstanceAvailability Operation</seealso>
        public virtual IAsyncResult BeginDescribeScheduledInstanceAvailability(DescribeScheduledInstanceAvailabilityRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeScheduledInstanceAvailabilityRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeScheduledInstanceAvailabilityResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeScheduledInstanceAvailability operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeScheduledInstanceAvailability.</param>
        /// 
        /// <returns>Returns a  DescribeScheduledInstanceAvailabilityResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeScheduledInstanceAvailability">REST API Reference for DescribeScheduledInstanceAvailability Operation</seealso>
        public virtual DescribeScheduledInstanceAvailabilityResponse EndDescribeScheduledInstanceAvailability(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeScheduledInstanceAvailabilityResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeScheduledInstances

        /// <summary>
        /// Describes the specified Scheduled Instances or all your Scheduled Instances.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeScheduledInstances service method.</param>
        /// 
        /// <returns>The response from the DescribeScheduledInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeScheduledInstances">REST API Reference for DescribeScheduledInstances Operation</seealso>
        public virtual DescribeScheduledInstancesResponse DescribeScheduledInstances(DescribeScheduledInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeScheduledInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeScheduledInstancesResponseUnmarshaller.Instance;

            return Invoke<DescribeScheduledInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeScheduledInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeScheduledInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeScheduledInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeScheduledInstances">REST API Reference for DescribeScheduledInstances Operation</seealso>
        public virtual IAsyncResult BeginDescribeScheduledInstances(DescribeScheduledInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeScheduledInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeScheduledInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeScheduledInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeScheduledInstances.</param>
        /// 
        /// <returns>Returns a  DescribeScheduledInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeScheduledInstances">REST API Reference for DescribeScheduledInstances Operation</seealso>
        public virtual DescribeScheduledInstancesResponse EndDescribeScheduledInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeScheduledInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSecurityGroupReferences

        /// <summary>
        /// Describes the VPCs on the other side of a VPC peering connection that are referencing
        /// the security groups you've specified in this request.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroupReferences service method.</param>
        /// 
        /// <returns>The response from the DescribeSecurityGroupReferences service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroupReferences">REST API Reference for DescribeSecurityGroupReferences Operation</seealso>
        public virtual DescribeSecurityGroupReferencesResponse DescribeSecurityGroupReferences(DescribeSecurityGroupReferencesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSecurityGroupReferencesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSecurityGroupReferencesResponseUnmarshaller.Instance;

            return Invoke<DescribeSecurityGroupReferencesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSecurityGroupReferences operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroupReferences operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSecurityGroupReferences
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroupReferences">REST API Reference for DescribeSecurityGroupReferences Operation</seealso>
        public virtual IAsyncResult BeginDescribeSecurityGroupReferences(DescribeSecurityGroupReferencesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSecurityGroupReferencesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSecurityGroupReferencesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSecurityGroupReferences operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSecurityGroupReferences.</param>
        /// 
        /// <returns>Returns a  DescribeSecurityGroupReferencesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroupReferences">REST API Reference for DescribeSecurityGroupReferences Operation</seealso>
        public virtual DescribeSecurityGroupReferencesResponse EndDescribeSecurityGroupReferences(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSecurityGroupReferencesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSecurityGroupRules

        /// <summary>
        /// Describes one or more of your security group rules.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroupRules service method.</param>
        /// 
        /// <returns>The response from the DescribeSecurityGroupRules service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroupRules">REST API Reference for DescribeSecurityGroupRules Operation</seealso>
        public virtual DescribeSecurityGroupRulesResponse DescribeSecurityGroupRules(DescribeSecurityGroupRulesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSecurityGroupRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSecurityGroupRulesResponseUnmarshaller.Instance;

            return Invoke<DescribeSecurityGroupRulesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSecurityGroupRules operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroupRules operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSecurityGroupRules
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroupRules">REST API Reference for DescribeSecurityGroupRules Operation</seealso>
        public virtual IAsyncResult BeginDescribeSecurityGroupRules(DescribeSecurityGroupRulesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSecurityGroupRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSecurityGroupRulesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSecurityGroupRules operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSecurityGroupRules.</param>
        /// 
        /// <returns>Returns a  DescribeSecurityGroupRulesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroupRules">REST API Reference for DescribeSecurityGroupRules Operation</seealso>
        public virtual DescribeSecurityGroupRulesResponse EndDescribeSecurityGroupRules(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSecurityGroupRulesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSecurityGroups

        /// <summary>
        /// Describes the specified security groups or all of your security groups.
        /// </summary>
        /// 
        /// <returns>The response from the DescribeSecurityGroups service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroups">REST API Reference for DescribeSecurityGroups Operation</seealso>
        public virtual DescribeSecurityGroupsResponse DescribeSecurityGroups()
        {
            return DescribeSecurityGroups(new DescribeSecurityGroupsRequest());
        }

        /// <summary>
        /// Describes the specified security groups or all of your security groups.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroups service method.</param>
        /// 
        /// <returns>The response from the DescribeSecurityGroups service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroups">REST API Reference for DescribeSecurityGroups Operation</seealso>
        public virtual DescribeSecurityGroupsResponse DescribeSecurityGroups(DescribeSecurityGroupsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSecurityGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSecurityGroupsResponseUnmarshaller.Instance;

            return Invoke<DescribeSecurityGroupsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSecurityGroups operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSecurityGroups operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSecurityGroups
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroups">REST API Reference for DescribeSecurityGroups Operation</seealso>
        public virtual IAsyncResult BeginDescribeSecurityGroups(DescribeSecurityGroupsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSecurityGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSecurityGroupsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSecurityGroups operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSecurityGroups.</param>
        /// 
        /// <returns>Returns a  DescribeSecurityGroupsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSecurityGroups">REST API Reference for DescribeSecurityGroups Operation</seealso>
        public virtual DescribeSecurityGroupsResponse EndDescribeSecurityGroups(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSecurityGroupsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSnapshotAttribute

        /// <summary>
        /// Describes the specified attribute of the specified snapshot. You can specify only
        /// one attribute at a time.
        /// 
        ///  
        /// <para>
        /// For more information about EBS snapshots, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSSnapshots.html">Amazon
        /// EBS snapshots</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSnapshotAttribute service method.</param>
        /// 
        /// <returns>The response from the DescribeSnapshotAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshotAttribute">REST API Reference for DescribeSnapshotAttribute Operation</seealso>
        public virtual DescribeSnapshotAttributeResponse DescribeSnapshotAttribute(DescribeSnapshotAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSnapshotAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSnapshotAttributeResponseUnmarshaller.Instance;

            return Invoke<DescribeSnapshotAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSnapshotAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSnapshotAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSnapshotAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshotAttribute">REST API Reference for DescribeSnapshotAttribute Operation</seealso>
        public virtual IAsyncResult BeginDescribeSnapshotAttribute(DescribeSnapshotAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSnapshotAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSnapshotAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSnapshotAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSnapshotAttribute.</param>
        /// 
        /// <returns>Returns a  DescribeSnapshotAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshotAttribute">REST API Reference for DescribeSnapshotAttribute Operation</seealso>
        public virtual DescribeSnapshotAttributeResponse EndDescribeSnapshotAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSnapshotAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSnapshots

        /// <summary>
        /// Describes the specified EBS snapshots available to you or all of the EBS snapshots
        /// available to you.
        /// 
        ///  
        /// <para>
        /// The snapshots available to you include public snapshots, private snapshots that you
        /// own, and private snapshots owned by other Amazon Web Services accounts for which you
        /// have explicit create volume permissions.
        /// </para>
        ///  
        /// <para>
        /// The create volume permissions fall into the following categories:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        ///  <i>public</i>: The owner of the snapshot granted create volume permissions for the
        /// snapshot to the <code>all</code> group. All Amazon Web Services accounts have create
        /// volume permissions for these snapshots.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <i>explicit</i>: The owner of the snapshot granted create volume permissions to a
        /// specific Amazon Web Services account.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <i>implicit</i>: An Amazon Web Services account has implicit create volume permissions
        /// for all snapshots it owns.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// The list of snapshots returned can be filtered by specifying snapshot IDs, snapshot
        /// owners, or Amazon Web Services accounts with create volume permissions. If no options
        /// are specified, Amazon EC2 returns all snapshots for which you have create volume permissions.
        /// </para>
        ///  
        /// <para>
        /// If you specify one or more snapshot IDs, only snapshots that have the specified IDs
        /// are returned. If you specify an invalid snapshot ID, an error is returned. If you
        /// specify a snapshot ID for which you do not have access, it is not included in the
        /// returned results.
        /// </para>
        ///  
        /// <para>
        /// If you specify one or more snapshot owners using the <code>OwnerIds</code> option,
        /// only snapshots from the specified owners and for which you have access are returned.
        /// The results can include the Amazon Web Services account IDs of the specified owners,
        /// <code>amazon</code> for snapshots owned by Amazon, or <code>self</code> for snapshots
        /// that you own.
        /// </para>
        ///  
        /// <para>
        /// If you specify a list of restorable users, only snapshots with create snapshot permissions
        /// for those users are returned. You can specify Amazon Web Services account IDs (if
        /// you own the snapshots), <code>self</code> for snapshots for which you own or have
        /// explicit permissions, or <code>all</code> for public snapshots.
        /// </para>
        ///  
        /// <para>
        /// If you are describing a long list of snapshots, we recommend that you paginate the
        /// output to make the list more manageable. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination">Pagination</a>.
        /// </para>
        ///  
        /// <para>
        /// To get the state of fast snapshot restores for a snapshot, use <a>DescribeFastSnapshotRestores</a>.
        /// </para>
        ///  
        /// <para>
        /// For more information about EBS snapshots, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSSnapshots.html">Amazon
        /// EBS snapshots</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeSnapshots service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshots">REST API Reference for DescribeSnapshots Operation</seealso>
        public virtual DescribeSnapshotsResponse DescribeSnapshots()
        {
            return DescribeSnapshots(new DescribeSnapshotsRequest());
        }

        /// <summary>
        /// Describes the specified EBS snapshots available to you or all of the EBS snapshots
        /// available to you.
        /// 
        ///  
        /// <para>
        /// The snapshots available to you include public snapshots, private snapshots that you
        /// own, and private snapshots owned by other Amazon Web Services accounts for which you
        /// have explicit create volume permissions.
        /// </para>
        ///  
        /// <para>
        /// The create volume permissions fall into the following categories:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        ///  <i>public</i>: The owner of the snapshot granted create volume permissions for the
        /// snapshot to the <code>all</code> group. All Amazon Web Services accounts have create
        /// volume permissions for these snapshots.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <i>explicit</i>: The owner of the snapshot granted create volume permissions to a
        /// specific Amazon Web Services account.
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <i>implicit</i>: An Amazon Web Services account has implicit create volume permissions
        /// for all snapshots it owns.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// The list of snapshots returned can be filtered by specifying snapshot IDs, snapshot
        /// owners, or Amazon Web Services accounts with create volume permissions. If no options
        /// are specified, Amazon EC2 returns all snapshots for which you have create volume permissions.
        /// </para>
        ///  
        /// <para>
        /// If you specify one or more snapshot IDs, only snapshots that have the specified IDs
        /// are returned. If you specify an invalid snapshot ID, an error is returned. If you
        /// specify a snapshot ID for which you do not have access, it is not included in the
        /// returned results.
        /// </para>
        ///  
        /// <para>
        /// If you specify one or more snapshot owners using the <code>OwnerIds</code> option,
        /// only snapshots from the specified owners and for which you have access are returned.
        /// The results can include the Amazon Web Services account IDs of the specified owners,
        /// <code>amazon</code> for snapshots owned by Amazon, or <code>self</code> for snapshots
        /// that you own.
        /// </para>
        ///  
        /// <para>
        /// If you specify a list of restorable users, only snapshots with create snapshot permissions
        /// for those users are returned. You can specify Amazon Web Services account IDs (if
        /// you own the snapshots), <code>self</code> for snapshots for which you own or have
        /// explicit permissions, or <code>all</code> for public snapshots.
        /// </para>
        ///  
        /// <para>
        /// If you are describing a long list of snapshots, we recommend that you paginate the
        /// output to make the list more manageable. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination">Pagination</a>.
        /// </para>
        ///  
        /// <para>
        /// To get the state of fast snapshot restores for a snapshot, use <a>DescribeFastSnapshotRestores</a>.
        /// </para>
        ///  
        /// <para>
        /// For more information about EBS snapshots, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSSnapshots.html">Amazon
        /// EBS snapshots</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSnapshots service method.</param>
        /// 
        /// <returns>The response from the DescribeSnapshots service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshots">REST API Reference for DescribeSnapshots Operation</seealso>
        public virtual DescribeSnapshotsResponse DescribeSnapshots(DescribeSnapshotsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance;

            return Invoke<DescribeSnapshotsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSnapshots operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSnapshots operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSnapshots
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshots">REST API Reference for DescribeSnapshots Operation</seealso>
        public virtual IAsyncResult BeginDescribeSnapshots(DescribeSnapshotsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSnapshots operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSnapshots.</param>
        /// 
        /// <returns>Returns a  DescribeSnapshotsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshots">REST API Reference for DescribeSnapshots Operation</seealso>
        public virtual DescribeSnapshotsResponse EndDescribeSnapshots(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSnapshotsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSnapshotTierStatus

        /// <summary>
        /// Describes the storage tier status of one or more Amazon EBS snapshots.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSnapshotTierStatus service method.</param>
        /// 
        /// <returns>The response from the DescribeSnapshotTierStatus service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshotTierStatus">REST API Reference for DescribeSnapshotTierStatus Operation</seealso>
        public virtual DescribeSnapshotTierStatusResponse DescribeSnapshotTierStatus(DescribeSnapshotTierStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSnapshotTierStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSnapshotTierStatusResponseUnmarshaller.Instance;

            return Invoke<DescribeSnapshotTierStatusResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSnapshotTierStatus operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSnapshotTierStatus operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSnapshotTierStatus
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshotTierStatus">REST API Reference for DescribeSnapshotTierStatus Operation</seealso>
        public virtual IAsyncResult BeginDescribeSnapshotTierStatus(DescribeSnapshotTierStatusRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSnapshotTierStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSnapshotTierStatusResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSnapshotTierStatus operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSnapshotTierStatus.</param>
        /// 
        /// <returns>Returns a  DescribeSnapshotTierStatusResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSnapshotTierStatus">REST API Reference for DescribeSnapshotTierStatus Operation</seealso>
        public virtual DescribeSnapshotTierStatusResponse EndDescribeSnapshotTierStatus(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSnapshotTierStatusResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSpotDatafeedSubscription

        /// <summary>
        /// Describes the data feed for Spot Instances. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html">Spot
        /// Instance data feed</a> in the <i>Amazon EC2 User Guide for Linux Instances</i>.
        /// </summary>
        /// 
        /// <returns>The response from the DescribeSpotDatafeedSubscription service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotDatafeedSubscription">REST API Reference for DescribeSpotDatafeedSubscription Operation</seealso>
        public virtual DescribeSpotDatafeedSubscriptionResponse DescribeSpotDatafeedSubscription()
        {
            return DescribeSpotDatafeedSubscription(new DescribeSpotDatafeedSubscriptionRequest());
        }

        /// <summary>
        /// Describes the data feed for Spot Instances. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-data-feeds.html">Spot
        /// Instance data feed</a> in the <i>Amazon EC2 User Guide for Linux Instances</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotDatafeedSubscription service method.</param>
        /// 
        /// <returns>The response from the DescribeSpotDatafeedSubscription service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotDatafeedSubscription">REST API Reference for DescribeSpotDatafeedSubscription Operation</seealso>
        public virtual DescribeSpotDatafeedSubscriptionResponse DescribeSpotDatafeedSubscription(DescribeSpotDatafeedSubscriptionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotDatafeedSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotDatafeedSubscriptionResponseUnmarshaller.Instance;

            return Invoke<DescribeSpotDatafeedSubscriptionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSpotDatafeedSubscription operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotDatafeedSubscription operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSpotDatafeedSubscription
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotDatafeedSubscription">REST API Reference for DescribeSpotDatafeedSubscription Operation</seealso>
        public virtual IAsyncResult BeginDescribeSpotDatafeedSubscription(DescribeSpotDatafeedSubscriptionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotDatafeedSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotDatafeedSubscriptionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSpotDatafeedSubscription operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSpotDatafeedSubscription.</param>
        /// 
        /// <returns>Returns a  DescribeSpotDatafeedSubscriptionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotDatafeedSubscription">REST API Reference for DescribeSpotDatafeedSubscription Operation</seealso>
        public virtual DescribeSpotDatafeedSubscriptionResponse EndDescribeSpotDatafeedSubscription(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSpotDatafeedSubscriptionResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSpotFleetInstances

        /// <summary>
        /// Describes the running instances for the specified Spot Fleet.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotFleetInstances service method.</param>
        /// 
        /// <returns>The response from the DescribeSpotFleetInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetInstances">REST API Reference for DescribeSpotFleetInstances Operation</seealso>
        public virtual DescribeSpotFleetInstancesResponse DescribeSpotFleetInstances(DescribeSpotFleetInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotFleetInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotFleetInstancesResponseUnmarshaller.Instance;

            return Invoke<DescribeSpotFleetInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSpotFleetInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotFleetInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSpotFleetInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetInstances">REST API Reference for DescribeSpotFleetInstances Operation</seealso>
        public virtual IAsyncResult BeginDescribeSpotFleetInstances(DescribeSpotFleetInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotFleetInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotFleetInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSpotFleetInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSpotFleetInstances.</param>
        /// 
        /// <returns>Returns a  DescribeSpotFleetInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetInstances">REST API Reference for DescribeSpotFleetInstances Operation</seealso>
        public virtual DescribeSpotFleetInstancesResponse EndDescribeSpotFleetInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSpotFleetInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSpotFleetRequestHistory

        /// <summary>
        /// Describes the events for the specified Spot Fleet request during the specified time.
        /// 
        ///  
        /// <para>
        /// Spot Fleet events are delayed by up to 30 seconds before they can be described. This
        /// ensures that you can query by the last evaluated time and not miss a recorded event.
        /// Spot Fleet events are available for 48 hours.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/fleet-monitor.html">Monitor
        /// fleet events using Amazon EventBridge</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotFleetRequestHistory service method.</param>
        /// 
        /// <returns>The response from the DescribeSpotFleetRequestHistory service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetRequestHistory">REST API Reference for DescribeSpotFleetRequestHistory Operation</seealso>
        public virtual DescribeSpotFleetRequestHistoryResponse DescribeSpotFleetRequestHistory(DescribeSpotFleetRequestHistoryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotFleetRequestHistoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotFleetRequestHistoryResponseUnmarshaller.Instance;

            return Invoke<DescribeSpotFleetRequestHistoryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSpotFleetRequestHistory operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotFleetRequestHistory operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSpotFleetRequestHistory
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetRequestHistory">REST API Reference for DescribeSpotFleetRequestHistory Operation</seealso>
        public virtual IAsyncResult BeginDescribeSpotFleetRequestHistory(DescribeSpotFleetRequestHistoryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotFleetRequestHistoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotFleetRequestHistoryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSpotFleetRequestHistory operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSpotFleetRequestHistory.</param>
        /// 
        /// <returns>Returns a  DescribeSpotFleetRequestHistoryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetRequestHistory">REST API Reference for DescribeSpotFleetRequestHistory Operation</seealso>
        public virtual DescribeSpotFleetRequestHistoryResponse EndDescribeSpotFleetRequestHistory(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSpotFleetRequestHistoryResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSpotFleetRequests

        /// <summary>
        /// Describes your Spot Fleet requests.
        /// 
        ///  
        /// <para>
        /// Spot Fleet requests are deleted 48 hours after they are canceled and their instances
        /// are terminated.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotFleetRequests service method.</param>
        /// 
        /// <returns>The response from the DescribeSpotFleetRequests service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetRequests">REST API Reference for DescribeSpotFleetRequests Operation</seealso>
        public virtual DescribeSpotFleetRequestsResponse DescribeSpotFleetRequests(DescribeSpotFleetRequestsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotFleetRequestsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotFleetRequestsResponseUnmarshaller.Instance;

            return Invoke<DescribeSpotFleetRequestsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSpotFleetRequests operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotFleetRequests operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSpotFleetRequests
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetRequests">REST API Reference for DescribeSpotFleetRequests Operation</seealso>
        public virtual IAsyncResult BeginDescribeSpotFleetRequests(DescribeSpotFleetRequestsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotFleetRequestsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotFleetRequestsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSpotFleetRequests operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSpotFleetRequests.</param>
        /// 
        /// <returns>Returns a  DescribeSpotFleetRequestsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotFleetRequests">REST API Reference for DescribeSpotFleetRequests Operation</seealso>
        public virtual DescribeSpotFleetRequestsResponse EndDescribeSpotFleetRequests(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSpotFleetRequestsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSpotInstanceRequests

        /// <summary>
        /// Describes the specified Spot Instance requests.
        /// 
        ///  
        /// <para>
        /// You can use <code>DescribeSpotInstanceRequests</code> to find a running Spot Instance
        /// by examining the response. If the status of the Spot Instance is <code>fulfilled</code>,
        /// the instance ID appears in the response and contains the identifier of the instance.
        /// Alternatively, you can use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances">DescribeInstances</a>
        /// with a filter to look for instances where the instance lifecycle is <code>spot</code>.
        /// </para>
        ///  
        /// <para>
        /// We recommend that you set <code>MaxResults</code> to a value between 5 and 1000 to
        /// limit the number of items returned. This paginates the output, which makes the list
        /// more manageable and returns the items faster. If the list of items exceeds your <code>MaxResults</code>
        /// value, then that number of items is returned along with a <code>NextToken</code> value
        /// that can be passed to a subsequent <code>DescribeSpotInstanceRequests</code> request
        /// to retrieve the remaining items.
        /// </para>
        ///  
        /// <para>
        /// Spot Instance requests are deleted four hours after they are canceled and their instances
        /// are terminated.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeSpotInstanceRequests service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotInstanceRequests">REST API Reference for DescribeSpotInstanceRequests Operation</seealso>
        public virtual DescribeSpotInstanceRequestsResponse DescribeSpotInstanceRequests()
        {
            return DescribeSpotInstanceRequests(new DescribeSpotInstanceRequestsRequest());
        }

        /// <summary>
        /// Describes the specified Spot Instance requests.
        /// 
        ///  
        /// <para>
        /// You can use <code>DescribeSpotInstanceRequests</code> to find a running Spot Instance
        /// by examining the response. If the status of the Spot Instance is <code>fulfilled</code>,
        /// the instance ID appears in the response and contains the identifier of the instance.
        /// Alternatively, you can use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances">DescribeInstances</a>
        /// with a filter to look for instances where the instance lifecycle is <code>spot</code>.
        /// </para>
        ///  
        /// <para>
        /// We recommend that you set <code>MaxResults</code> to a value between 5 and 1000 to
        /// limit the number of items returned. This paginates the output, which makes the list
        /// more manageable and returns the items faster. If the list of items exceeds your <code>MaxResults</code>
        /// value, then that number of items is returned along with a <code>NextToken</code> value
        /// that can be passed to a subsequent <code>DescribeSpotInstanceRequests</code> request
        /// to retrieve the remaining items.
        /// </para>
        ///  
        /// <para>
        /// Spot Instance requests are deleted four hours after they are canceled and their instances
        /// are terminated.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotInstanceRequests service method.</param>
        /// 
        /// <returns>The response from the DescribeSpotInstanceRequests service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotInstanceRequests">REST API Reference for DescribeSpotInstanceRequests Operation</seealso>
        public virtual DescribeSpotInstanceRequestsResponse DescribeSpotInstanceRequests(DescribeSpotInstanceRequestsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotInstanceRequestsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotInstanceRequestsResponseUnmarshaller.Instance;

            return Invoke<DescribeSpotInstanceRequestsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSpotInstanceRequests operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotInstanceRequests operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSpotInstanceRequests
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotInstanceRequests">REST API Reference for DescribeSpotInstanceRequests Operation</seealso>
        public virtual IAsyncResult BeginDescribeSpotInstanceRequests(DescribeSpotInstanceRequestsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotInstanceRequestsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotInstanceRequestsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSpotInstanceRequests operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSpotInstanceRequests.</param>
        /// 
        /// <returns>Returns a  DescribeSpotInstanceRequestsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotInstanceRequests">REST API Reference for DescribeSpotInstanceRequests Operation</seealso>
        public virtual DescribeSpotInstanceRequestsResponse EndDescribeSpotInstanceRequests(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSpotInstanceRequestsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSpotPriceHistory

        /// <summary>
        /// Describes the Spot price history. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html">Spot
        /// Instance pricing history</a> in the <i>Amazon EC2 User Guide for Linux Instances</i>.
        /// 
        ///  
        /// <para>
        /// When you specify a start and end time, the operation returns the prices of the instance
        /// types within that time range. It also returns the last price change before the start
        /// time, which is the effective price as of the start time.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeSpotPriceHistory service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotPriceHistory">REST API Reference for DescribeSpotPriceHistory Operation</seealso>
        public virtual DescribeSpotPriceHistoryResponse DescribeSpotPriceHistory()
        {
            return DescribeSpotPriceHistory(new DescribeSpotPriceHistoryRequest());
        }

        /// <summary>
        /// Describes the Spot price history. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances-history.html">Spot
        /// Instance pricing history</a> in the <i>Amazon EC2 User Guide for Linux Instances</i>.
        /// 
        ///  
        /// <para>
        /// When you specify a start and end time, the operation returns the prices of the instance
        /// types within that time range. It also returns the last price change before the start
        /// time, which is the effective price as of the start time.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotPriceHistory service method.</param>
        /// 
        /// <returns>The response from the DescribeSpotPriceHistory service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotPriceHistory">REST API Reference for DescribeSpotPriceHistory Operation</seealso>
        public virtual DescribeSpotPriceHistoryResponse DescribeSpotPriceHistory(DescribeSpotPriceHistoryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotPriceHistoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotPriceHistoryResponseUnmarshaller.Instance;

            return Invoke<DescribeSpotPriceHistoryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSpotPriceHistory operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSpotPriceHistory operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSpotPriceHistory
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotPriceHistory">REST API Reference for DescribeSpotPriceHistory Operation</seealso>
        public virtual IAsyncResult BeginDescribeSpotPriceHistory(DescribeSpotPriceHistoryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSpotPriceHistoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSpotPriceHistoryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSpotPriceHistory operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSpotPriceHistory.</param>
        /// 
        /// <returns>Returns a  DescribeSpotPriceHistoryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSpotPriceHistory">REST API Reference for DescribeSpotPriceHistory Operation</seealso>
        public virtual DescribeSpotPriceHistoryResponse EndDescribeSpotPriceHistory(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSpotPriceHistoryResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeStaleSecurityGroups

        /// <summary>
        /// Describes the stale security group rules for security groups in a specified VPC. Rules
        /// are stale when they reference a deleted security group in the same VPC or in a peer
        /// VPC, or if they reference a security group in a peer VPC for which the VPC peering
        /// connection has been deleted.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeStaleSecurityGroups service method.</param>
        /// 
        /// <returns>The response from the DescribeStaleSecurityGroups service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeStaleSecurityGroups">REST API Reference for DescribeStaleSecurityGroups Operation</seealso>
        public virtual DescribeStaleSecurityGroupsResponse DescribeStaleSecurityGroups(DescribeStaleSecurityGroupsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeStaleSecurityGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeStaleSecurityGroupsResponseUnmarshaller.Instance;

            return Invoke<DescribeStaleSecurityGroupsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeStaleSecurityGroups operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeStaleSecurityGroups operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeStaleSecurityGroups
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeStaleSecurityGroups">REST API Reference for DescribeStaleSecurityGroups Operation</seealso>
        public virtual IAsyncResult BeginDescribeStaleSecurityGroups(DescribeStaleSecurityGroupsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeStaleSecurityGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeStaleSecurityGroupsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeStaleSecurityGroups operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeStaleSecurityGroups.</param>
        /// 
        /// <returns>Returns a  DescribeStaleSecurityGroupsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeStaleSecurityGroups">REST API Reference for DescribeStaleSecurityGroups Operation</seealso>
        public virtual DescribeStaleSecurityGroupsResponse EndDescribeStaleSecurityGroups(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeStaleSecurityGroupsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeStoreImageTasks

        /// <summary>
        /// Describes the progress of the AMI store tasks. You can describe the store tasks for
        /// specified AMIs. If you don't specify the AMIs, you get a paginated list of store tasks
        /// from the last 31 days.
        /// 
        ///  
        /// <para>
        /// For each AMI task, the response indicates if the task is <code>InProgress</code>,
        /// <code>Completed</code>, or <code>Failed</code>. For tasks <code>InProgress</code>,
        /// the response shows the estimated progress as a percentage.
        /// </para>
        ///  
        /// <para>
        /// Tasks are listed in reverse chronological order. Currently, only tasks from the past
        /// 31 days can be viewed.
        /// </para>
        ///  
        /// <para>
        /// To use this API, you must have the required permissions. For more information, see
        /// <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html#ami-s3-permissions">Permissions
        /// for storing and restoring AMIs using Amazon S3</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html">Store
        /// and restore an AMI using Amazon S3</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeStoreImageTasks service method.</param>
        /// 
        /// <returns>The response from the DescribeStoreImageTasks service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeStoreImageTasks">REST API Reference for DescribeStoreImageTasks Operation</seealso>
        public virtual DescribeStoreImageTasksResponse DescribeStoreImageTasks(DescribeStoreImageTasksRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeStoreImageTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeStoreImageTasksResponseUnmarshaller.Instance;

            return Invoke<DescribeStoreImageTasksResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeStoreImageTasks operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeStoreImageTasks operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeStoreImageTasks
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeStoreImageTasks">REST API Reference for DescribeStoreImageTasks Operation</seealso>
        public virtual IAsyncResult BeginDescribeStoreImageTasks(DescribeStoreImageTasksRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeStoreImageTasksRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeStoreImageTasksResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeStoreImageTasks operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeStoreImageTasks.</param>
        /// 
        /// <returns>Returns a  DescribeStoreImageTasksResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeStoreImageTasks">REST API Reference for DescribeStoreImageTasks Operation</seealso>
        public virtual DescribeStoreImageTasksResponse EndDescribeStoreImageTasks(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeStoreImageTasksResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeSubnets

        /// <summary>
        /// Describes one or more of your subnets.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/configure-subnets.html">Subnets</a>
        /// in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeSubnets service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSubnets">REST API Reference for DescribeSubnets Operation</seealso>
        public virtual DescribeSubnetsResponse DescribeSubnets()
        {
            return DescribeSubnets(new DescribeSubnetsRequest());
        }

        /// <summary>
        /// Describes one or more of your subnets.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/configure-subnets.html">Subnets</a>
        /// in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeSubnets service method.</param>
        /// 
        /// <returns>The response from the DescribeSubnets service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSubnets">REST API Reference for DescribeSubnets Operation</seealso>
        public virtual DescribeSubnetsResponse DescribeSubnets(DescribeSubnetsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSubnetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSubnetsResponseUnmarshaller.Instance;

            return Invoke<DescribeSubnetsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeSubnets operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeSubnets operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSubnets
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSubnets">REST API Reference for DescribeSubnets Operation</seealso>
        public virtual IAsyncResult BeginDescribeSubnets(DescribeSubnetsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeSubnetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeSubnetsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeSubnets operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeSubnets.</param>
        /// 
        /// <returns>Returns a  DescribeSubnetsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeSubnets">REST API Reference for DescribeSubnets Operation</seealso>
        public virtual DescribeSubnetsResponse EndDescribeSubnets(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeSubnetsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTags

        /// <summary>
        /// Describes the specified tags for your EC2 resources.
        /// 
        ///  
        /// <para>
        /// For more information about tags, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
        /// your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeTags service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTags">REST API Reference for DescribeTags Operation</seealso>
        public virtual DescribeTagsResponse DescribeTags()
        {
            return DescribeTags(new DescribeTagsRequest());
        }

        /// <summary>
        /// Describes the specified tags for your EC2 resources.
        /// 
        ///  
        /// <para>
        /// For more information about tags, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tag
        /// your Amazon EC2 resources</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTags service method.</param>
        /// 
        /// <returns>The response from the DescribeTags service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTags">REST API Reference for DescribeTags Operation</seealso>
        public virtual DescribeTagsResponse DescribeTags(DescribeTagsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTagsResponseUnmarshaller.Instance;

            return Invoke<DescribeTagsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTags operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTags operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTags
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTags">REST API Reference for DescribeTags Operation</seealso>
        public virtual IAsyncResult BeginDescribeTags(DescribeTagsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTagsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTagsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTags operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTags.</param>
        /// 
        /// <returns>Returns a  DescribeTagsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTags">REST API Reference for DescribeTags Operation</seealso>
        public virtual DescribeTagsResponse EndDescribeTags(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTagsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTrafficMirrorFilters

        /// <summary>
        /// Describes one or more Traffic Mirror filters.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTrafficMirrorFilters service method.</param>
        /// 
        /// <returns>The response from the DescribeTrafficMirrorFilters service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorFilters">REST API Reference for DescribeTrafficMirrorFilters Operation</seealso>
        public virtual DescribeTrafficMirrorFiltersResponse DescribeTrafficMirrorFilters(DescribeTrafficMirrorFiltersRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTrafficMirrorFiltersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTrafficMirrorFiltersResponseUnmarshaller.Instance;

            return Invoke<DescribeTrafficMirrorFiltersResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTrafficMirrorFilters operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTrafficMirrorFilters operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTrafficMirrorFilters
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorFilters">REST API Reference for DescribeTrafficMirrorFilters Operation</seealso>
        public virtual IAsyncResult BeginDescribeTrafficMirrorFilters(DescribeTrafficMirrorFiltersRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTrafficMirrorFiltersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTrafficMirrorFiltersResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTrafficMirrorFilters operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTrafficMirrorFilters.</param>
        /// 
        /// <returns>Returns a  DescribeTrafficMirrorFiltersResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorFilters">REST API Reference for DescribeTrafficMirrorFilters Operation</seealso>
        public virtual DescribeTrafficMirrorFiltersResponse EndDescribeTrafficMirrorFilters(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTrafficMirrorFiltersResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTrafficMirrorSessions

        /// <summary>
        /// Describes one or more Traffic Mirror sessions. By default, all Traffic Mirror sessions
        /// are described. Alternatively, you can filter the results.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTrafficMirrorSessions service method.</param>
        /// 
        /// <returns>The response from the DescribeTrafficMirrorSessions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorSessions">REST API Reference for DescribeTrafficMirrorSessions Operation</seealso>
        public virtual DescribeTrafficMirrorSessionsResponse DescribeTrafficMirrorSessions(DescribeTrafficMirrorSessionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTrafficMirrorSessionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTrafficMirrorSessionsResponseUnmarshaller.Instance;

            return Invoke<DescribeTrafficMirrorSessionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTrafficMirrorSessions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTrafficMirrorSessions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTrafficMirrorSessions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorSessions">REST API Reference for DescribeTrafficMirrorSessions Operation</seealso>
        public virtual IAsyncResult BeginDescribeTrafficMirrorSessions(DescribeTrafficMirrorSessionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTrafficMirrorSessionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTrafficMirrorSessionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTrafficMirrorSessions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTrafficMirrorSessions.</param>
        /// 
        /// <returns>Returns a  DescribeTrafficMirrorSessionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorSessions">REST API Reference for DescribeTrafficMirrorSessions Operation</seealso>
        public virtual DescribeTrafficMirrorSessionsResponse EndDescribeTrafficMirrorSessions(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTrafficMirrorSessionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTrafficMirrorTargets

        /// <summary>
        /// Information about one or more Traffic Mirror targets.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTrafficMirrorTargets service method.</param>
        /// 
        /// <returns>The response from the DescribeTrafficMirrorTargets service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorTargets">REST API Reference for DescribeTrafficMirrorTargets Operation</seealso>
        public virtual DescribeTrafficMirrorTargetsResponse DescribeTrafficMirrorTargets(DescribeTrafficMirrorTargetsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTrafficMirrorTargetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTrafficMirrorTargetsResponseUnmarshaller.Instance;

            return Invoke<DescribeTrafficMirrorTargetsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTrafficMirrorTargets operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTrafficMirrorTargets operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTrafficMirrorTargets
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorTargets">REST API Reference for DescribeTrafficMirrorTargets Operation</seealso>
        public virtual IAsyncResult BeginDescribeTrafficMirrorTargets(DescribeTrafficMirrorTargetsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTrafficMirrorTargetsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTrafficMirrorTargetsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTrafficMirrorTargets operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTrafficMirrorTargets.</param>
        /// 
        /// <returns>Returns a  DescribeTrafficMirrorTargetsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrafficMirrorTargets">REST API Reference for DescribeTrafficMirrorTargets Operation</seealso>
        public virtual DescribeTrafficMirrorTargetsResponse EndDescribeTrafficMirrorTargets(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTrafficMirrorTargetsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGatewayAttachments

        /// <summary>
        /// Describes one or more attachments between resources and transit gateways. By default,
        /// all attachments are described. Alternatively, you can filter the results by attachment
        /// ID, attachment state, resource ID, or resource owner.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayAttachments service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGatewayAttachments service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayAttachments">REST API Reference for DescribeTransitGatewayAttachments Operation</seealso>
        public virtual DescribeTransitGatewayAttachmentsResponse DescribeTransitGatewayAttachments(DescribeTransitGatewayAttachmentsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayAttachmentsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayAttachmentsResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewayAttachmentsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGatewayAttachments operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayAttachments operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGatewayAttachments
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayAttachments">REST API Reference for DescribeTransitGatewayAttachments Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGatewayAttachments(DescribeTransitGatewayAttachmentsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayAttachmentsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayAttachmentsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGatewayAttachments operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGatewayAttachments.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewayAttachmentsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayAttachments">REST API Reference for DescribeTransitGatewayAttachments Operation</seealso>
        public virtual DescribeTransitGatewayAttachmentsResponse EndDescribeTransitGatewayAttachments(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewayAttachmentsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGatewayConnectPeers

        /// <summary>
        /// Describes one or more Connect peers.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayConnectPeers service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGatewayConnectPeers service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayConnectPeers">REST API Reference for DescribeTransitGatewayConnectPeers Operation</seealso>
        public virtual DescribeTransitGatewayConnectPeersResponse DescribeTransitGatewayConnectPeers(DescribeTransitGatewayConnectPeersRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayConnectPeersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayConnectPeersResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewayConnectPeersResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGatewayConnectPeers operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayConnectPeers operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGatewayConnectPeers
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayConnectPeers">REST API Reference for DescribeTransitGatewayConnectPeers Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGatewayConnectPeers(DescribeTransitGatewayConnectPeersRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayConnectPeersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayConnectPeersResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGatewayConnectPeers operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGatewayConnectPeers.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewayConnectPeersResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayConnectPeers">REST API Reference for DescribeTransitGatewayConnectPeers Operation</seealso>
        public virtual DescribeTransitGatewayConnectPeersResponse EndDescribeTransitGatewayConnectPeers(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewayConnectPeersResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGatewayConnects

        /// <summary>
        /// Describes one or more Connect attachments.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayConnects service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGatewayConnects service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayConnects">REST API Reference for DescribeTransitGatewayConnects Operation</seealso>
        public virtual DescribeTransitGatewayConnectsResponse DescribeTransitGatewayConnects(DescribeTransitGatewayConnectsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayConnectsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayConnectsResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewayConnectsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGatewayConnects operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayConnects operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGatewayConnects
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayConnects">REST API Reference for DescribeTransitGatewayConnects Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGatewayConnects(DescribeTransitGatewayConnectsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayConnectsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayConnectsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGatewayConnects operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGatewayConnects.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewayConnectsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayConnects">REST API Reference for DescribeTransitGatewayConnects Operation</seealso>
        public virtual DescribeTransitGatewayConnectsResponse EndDescribeTransitGatewayConnects(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewayConnectsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGatewayMulticastDomains

        /// <summary>
        /// Describes one or more transit gateway multicast domains.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayMulticastDomains service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGatewayMulticastDomains service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayMulticastDomains">REST API Reference for DescribeTransitGatewayMulticastDomains Operation</seealso>
        public virtual DescribeTransitGatewayMulticastDomainsResponse DescribeTransitGatewayMulticastDomains(DescribeTransitGatewayMulticastDomainsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayMulticastDomainsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayMulticastDomainsResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewayMulticastDomainsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGatewayMulticastDomains operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayMulticastDomains operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGatewayMulticastDomains
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayMulticastDomains">REST API Reference for DescribeTransitGatewayMulticastDomains Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGatewayMulticastDomains(DescribeTransitGatewayMulticastDomainsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayMulticastDomainsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayMulticastDomainsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGatewayMulticastDomains operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGatewayMulticastDomains.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewayMulticastDomainsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayMulticastDomains">REST API Reference for DescribeTransitGatewayMulticastDomains Operation</seealso>
        public virtual DescribeTransitGatewayMulticastDomainsResponse EndDescribeTransitGatewayMulticastDomains(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewayMulticastDomainsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGatewayPeeringAttachments

        /// <summary>
        /// Describes your transit gateway peering attachments.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayPeeringAttachments service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGatewayPeeringAttachments service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayPeeringAttachments">REST API Reference for DescribeTransitGatewayPeeringAttachments Operation</seealso>
        public virtual DescribeTransitGatewayPeeringAttachmentsResponse DescribeTransitGatewayPeeringAttachments(DescribeTransitGatewayPeeringAttachmentsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayPeeringAttachmentsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayPeeringAttachmentsResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewayPeeringAttachmentsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGatewayPeeringAttachments operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayPeeringAttachments operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGatewayPeeringAttachments
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayPeeringAttachments">REST API Reference for DescribeTransitGatewayPeeringAttachments Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGatewayPeeringAttachments(DescribeTransitGatewayPeeringAttachmentsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayPeeringAttachmentsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayPeeringAttachmentsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGatewayPeeringAttachments operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGatewayPeeringAttachments.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewayPeeringAttachmentsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayPeeringAttachments">REST API Reference for DescribeTransitGatewayPeeringAttachments Operation</seealso>
        public virtual DescribeTransitGatewayPeeringAttachmentsResponse EndDescribeTransitGatewayPeeringAttachments(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewayPeeringAttachmentsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGatewayPolicyTables

        /// <summary>
        /// Describes one or more transit gateway route policy tables.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayPolicyTables service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGatewayPolicyTables service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayPolicyTables">REST API Reference for DescribeTransitGatewayPolicyTables Operation</seealso>
        public virtual DescribeTransitGatewayPolicyTablesResponse DescribeTransitGatewayPolicyTables(DescribeTransitGatewayPolicyTablesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayPolicyTablesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayPolicyTablesResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewayPolicyTablesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGatewayPolicyTables operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayPolicyTables operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGatewayPolicyTables
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayPolicyTables">REST API Reference for DescribeTransitGatewayPolicyTables Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGatewayPolicyTables(DescribeTransitGatewayPolicyTablesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayPolicyTablesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayPolicyTablesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGatewayPolicyTables operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGatewayPolicyTables.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewayPolicyTablesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayPolicyTables">REST API Reference for DescribeTransitGatewayPolicyTables Operation</seealso>
        public virtual DescribeTransitGatewayPolicyTablesResponse EndDescribeTransitGatewayPolicyTables(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewayPolicyTablesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGatewayRouteTableAnnouncements

        /// <summary>
        /// Describes one or more transit gateway route table advertisements.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayRouteTableAnnouncements service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGatewayRouteTableAnnouncements service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayRouteTableAnnouncements">REST API Reference for DescribeTransitGatewayRouteTableAnnouncements Operation</seealso>
        public virtual DescribeTransitGatewayRouteTableAnnouncementsResponse DescribeTransitGatewayRouteTableAnnouncements(DescribeTransitGatewayRouteTableAnnouncementsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayRouteTableAnnouncementsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayRouteTableAnnouncementsResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewayRouteTableAnnouncementsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGatewayRouteTableAnnouncements operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayRouteTableAnnouncements operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGatewayRouteTableAnnouncements
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayRouteTableAnnouncements">REST API Reference for DescribeTransitGatewayRouteTableAnnouncements Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGatewayRouteTableAnnouncements(DescribeTransitGatewayRouteTableAnnouncementsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayRouteTableAnnouncementsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayRouteTableAnnouncementsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGatewayRouteTableAnnouncements operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGatewayRouteTableAnnouncements.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewayRouteTableAnnouncementsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayRouteTableAnnouncements">REST API Reference for DescribeTransitGatewayRouteTableAnnouncements Operation</seealso>
        public virtual DescribeTransitGatewayRouteTableAnnouncementsResponse EndDescribeTransitGatewayRouteTableAnnouncements(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewayRouteTableAnnouncementsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGatewayRouteTables

        /// <summary>
        /// Describes one or more transit gateway route tables. By default, all transit gateway
        /// route tables are described. Alternatively, you can filter the results.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayRouteTables service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGatewayRouteTables service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayRouteTables">REST API Reference for DescribeTransitGatewayRouteTables Operation</seealso>
        public virtual DescribeTransitGatewayRouteTablesResponse DescribeTransitGatewayRouteTables(DescribeTransitGatewayRouteTablesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayRouteTablesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayRouteTablesResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewayRouteTablesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGatewayRouteTables operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayRouteTables operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGatewayRouteTables
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayRouteTables">REST API Reference for DescribeTransitGatewayRouteTables Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGatewayRouteTables(DescribeTransitGatewayRouteTablesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayRouteTablesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayRouteTablesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGatewayRouteTables operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGatewayRouteTables.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewayRouteTablesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayRouteTables">REST API Reference for DescribeTransitGatewayRouteTables Operation</seealso>
        public virtual DescribeTransitGatewayRouteTablesResponse EndDescribeTransitGatewayRouteTables(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewayRouteTablesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGateways

        /// <summary>
        /// Describes one or more transit gateways. By default, all transit gateways are described.
        /// Alternatively, you can filter the results.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGateways service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGateways">REST API Reference for DescribeTransitGateways Operation</seealso>
        public virtual DescribeTransitGatewaysResponse DescribeTransitGateways(DescribeTransitGatewaysRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewaysResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewaysResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGateways operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGateways operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGateways
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGateways">REST API Reference for DescribeTransitGateways Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGateways(DescribeTransitGatewaysRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewaysResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGateways operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGateways.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewaysResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGateways">REST API Reference for DescribeTransitGateways Operation</seealso>
        public virtual DescribeTransitGatewaysResponse EndDescribeTransitGateways(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewaysResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTransitGatewayVpcAttachments

        /// <summary>
        /// Describes one or more VPC attachments. By default, all VPC attachments are described.
        /// Alternatively, you can filter the results.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayVpcAttachments service method.</param>
        /// 
        /// <returns>The response from the DescribeTransitGatewayVpcAttachments service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayVpcAttachments">REST API Reference for DescribeTransitGatewayVpcAttachments Operation</seealso>
        public virtual DescribeTransitGatewayVpcAttachmentsResponse DescribeTransitGatewayVpcAttachments(DescribeTransitGatewayVpcAttachmentsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayVpcAttachmentsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayVpcAttachmentsResponseUnmarshaller.Instance;

            return Invoke<DescribeTransitGatewayVpcAttachmentsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTransitGatewayVpcAttachments operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTransitGatewayVpcAttachments operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTransitGatewayVpcAttachments
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayVpcAttachments">REST API Reference for DescribeTransitGatewayVpcAttachments Operation</seealso>
        public virtual IAsyncResult BeginDescribeTransitGatewayVpcAttachments(DescribeTransitGatewayVpcAttachmentsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTransitGatewayVpcAttachmentsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTransitGatewayVpcAttachmentsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTransitGatewayVpcAttachments operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTransitGatewayVpcAttachments.</param>
        /// 
        /// <returns>Returns a  DescribeTransitGatewayVpcAttachmentsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTransitGatewayVpcAttachments">REST API Reference for DescribeTransitGatewayVpcAttachments Operation</seealso>
        public virtual DescribeTransitGatewayVpcAttachmentsResponse EndDescribeTransitGatewayVpcAttachments(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTransitGatewayVpcAttachmentsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeTrunkInterfaceAssociations

        /// <summary>
        /// <note> 
        /// <para>
        /// This API action is currently in <b>limited preview only</b>. If you are interested
        /// in using this feature, contact your account manager.
        /// </para>
        ///  </note> 
        /// <para>
        /// Describes one or more network interface trunk associations.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeTrunkInterfaceAssociations service method.</param>
        /// 
        /// <returns>The response from the DescribeTrunkInterfaceAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrunkInterfaceAssociations">REST API Reference for DescribeTrunkInterfaceAssociations Operation</seealso>
        public virtual DescribeTrunkInterfaceAssociationsResponse DescribeTrunkInterfaceAssociations(DescribeTrunkInterfaceAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTrunkInterfaceAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTrunkInterfaceAssociationsResponseUnmarshaller.Instance;

            return Invoke<DescribeTrunkInterfaceAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeTrunkInterfaceAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeTrunkInterfaceAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTrunkInterfaceAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrunkInterfaceAssociations">REST API Reference for DescribeTrunkInterfaceAssociations Operation</seealso>
        public virtual IAsyncResult BeginDescribeTrunkInterfaceAssociations(DescribeTrunkInterfaceAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeTrunkInterfaceAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeTrunkInterfaceAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeTrunkInterfaceAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeTrunkInterfaceAssociations.</param>
        /// 
        /// <returns>Returns a  DescribeTrunkInterfaceAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeTrunkInterfaceAssociations">REST API Reference for DescribeTrunkInterfaceAssociations Operation</seealso>
        public virtual DescribeTrunkInterfaceAssociationsResponse EndDescribeTrunkInterfaceAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeTrunkInterfaceAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVerifiedAccessEndpoints

        /// <summary>
        /// Describes the specified Amazon Web Services Verified Access endpoints.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessEndpoints service method.</param>
        /// 
        /// <returns>The response from the DescribeVerifiedAccessEndpoints service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessEndpoints">REST API Reference for DescribeVerifiedAccessEndpoints Operation</seealso>
        public virtual DescribeVerifiedAccessEndpointsResponse DescribeVerifiedAccessEndpoints(DescribeVerifiedAccessEndpointsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessEndpointsResponseUnmarshaller.Instance;

            return Invoke<DescribeVerifiedAccessEndpointsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVerifiedAccessEndpoints operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessEndpoints operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVerifiedAccessEndpoints
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessEndpoints">REST API Reference for DescribeVerifiedAccessEndpoints Operation</seealso>
        public virtual IAsyncResult BeginDescribeVerifiedAccessEndpoints(DescribeVerifiedAccessEndpointsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessEndpointsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVerifiedAccessEndpoints operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVerifiedAccessEndpoints.</param>
        /// 
        /// <returns>Returns a  DescribeVerifiedAccessEndpointsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessEndpoints">REST API Reference for DescribeVerifiedAccessEndpoints Operation</seealso>
        public virtual DescribeVerifiedAccessEndpointsResponse EndDescribeVerifiedAccessEndpoints(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVerifiedAccessEndpointsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVerifiedAccessGroups

        /// <summary>
        /// Describes the specified Verified Access groups.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessGroups service method.</param>
        /// 
        /// <returns>The response from the DescribeVerifiedAccessGroups service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessGroups">REST API Reference for DescribeVerifiedAccessGroups Operation</seealso>
        public virtual DescribeVerifiedAccessGroupsResponse DescribeVerifiedAccessGroups(DescribeVerifiedAccessGroupsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessGroupsResponseUnmarshaller.Instance;

            return Invoke<DescribeVerifiedAccessGroupsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVerifiedAccessGroups operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessGroups operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVerifiedAccessGroups
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessGroups">REST API Reference for DescribeVerifiedAccessGroups Operation</seealso>
        public virtual IAsyncResult BeginDescribeVerifiedAccessGroups(DescribeVerifiedAccessGroupsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessGroupsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVerifiedAccessGroups operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVerifiedAccessGroups.</param>
        /// 
        /// <returns>Returns a  DescribeVerifiedAccessGroupsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessGroups">REST API Reference for DescribeVerifiedAccessGroups Operation</seealso>
        public virtual DescribeVerifiedAccessGroupsResponse EndDescribeVerifiedAccessGroups(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVerifiedAccessGroupsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVerifiedAccessInstanceLoggingConfigurations

        /// <summary>
        /// Describes the specified Amazon Web Services Verified Access instances.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessInstanceLoggingConfigurations service method.</param>
        /// 
        /// <returns>The response from the DescribeVerifiedAccessInstanceLoggingConfigurations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessInstanceLoggingConfigurations">REST API Reference for DescribeVerifiedAccessInstanceLoggingConfigurations Operation</seealso>
        public virtual DescribeVerifiedAccessInstanceLoggingConfigurationsResponse DescribeVerifiedAccessInstanceLoggingConfigurations(DescribeVerifiedAccessInstanceLoggingConfigurationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessInstanceLoggingConfigurationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessInstanceLoggingConfigurationsResponseUnmarshaller.Instance;

            return Invoke<DescribeVerifiedAccessInstanceLoggingConfigurationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVerifiedAccessInstanceLoggingConfigurations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessInstanceLoggingConfigurations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVerifiedAccessInstanceLoggingConfigurations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessInstanceLoggingConfigurations">REST API Reference for DescribeVerifiedAccessInstanceLoggingConfigurations Operation</seealso>
        public virtual IAsyncResult BeginDescribeVerifiedAccessInstanceLoggingConfigurations(DescribeVerifiedAccessInstanceLoggingConfigurationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessInstanceLoggingConfigurationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessInstanceLoggingConfigurationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVerifiedAccessInstanceLoggingConfigurations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVerifiedAccessInstanceLoggingConfigurations.</param>
        /// 
        /// <returns>Returns a  DescribeVerifiedAccessInstanceLoggingConfigurationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessInstanceLoggingConfigurations">REST API Reference for DescribeVerifiedAccessInstanceLoggingConfigurations Operation</seealso>
        public virtual DescribeVerifiedAccessInstanceLoggingConfigurationsResponse EndDescribeVerifiedAccessInstanceLoggingConfigurations(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVerifiedAccessInstanceLoggingConfigurationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVerifiedAccessInstances

        /// <summary>
        /// Describes the specified Amazon Web Services Verified Access instances.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessInstances service method.</param>
        /// 
        /// <returns>The response from the DescribeVerifiedAccessInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessInstances">REST API Reference for DescribeVerifiedAccessInstances Operation</seealso>
        public virtual DescribeVerifiedAccessInstancesResponse DescribeVerifiedAccessInstances(DescribeVerifiedAccessInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessInstancesResponseUnmarshaller.Instance;

            return Invoke<DescribeVerifiedAccessInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVerifiedAccessInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVerifiedAccessInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessInstances">REST API Reference for DescribeVerifiedAccessInstances Operation</seealso>
        public virtual IAsyncResult BeginDescribeVerifiedAccessInstances(DescribeVerifiedAccessInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVerifiedAccessInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVerifiedAccessInstances.</param>
        /// 
        /// <returns>Returns a  DescribeVerifiedAccessInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessInstances">REST API Reference for DescribeVerifiedAccessInstances Operation</seealso>
        public virtual DescribeVerifiedAccessInstancesResponse EndDescribeVerifiedAccessInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVerifiedAccessInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVerifiedAccessTrustProviders

        /// <summary>
        /// Describes the specified Amazon Web Services Verified Access trust providers.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessTrustProviders service method.</param>
        /// 
        /// <returns>The response from the DescribeVerifiedAccessTrustProviders service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessTrustProviders">REST API Reference for DescribeVerifiedAccessTrustProviders Operation</seealso>
        public virtual DescribeVerifiedAccessTrustProvidersResponse DescribeVerifiedAccessTrustProviders(DescribeVerifiedAccessTrustProvidersRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessTrustProvidersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessTrustProvidersResponseUnmarshaller.Instance;

            return Invoke<DescribeVerifiedAccessTrustProvidersResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVerifiedAccessTrustProviders operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVerifiedAccessTrustProviders operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVerifiedAccessTrustProviders
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessTrustProviders">REST API Reference for DescribeVerifiedAccessTrustProviders Operation</seealso>
        public virtual IAsyncResult BeginDescribeVerifiedAccessTrustProviders(DescribeVerifiedAccessTrustProvidersRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVerifiedAccessTrustProvidersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVerifiedAccessTrustProvidersResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVerifiedAccessTrustProviders operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVerifiedAccessTrustProviders.</param>
        /// 
        /// <returns>Returns a  DescribeVerifiedAccessTrustProvidersResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVerifiedAccessTrustProviders">REST API Reference for DescribeVerifiedAccessTrustProviders Operation</seealso>
        public virtual DescribeVerifiedAccessTrustProvidersResponse EndDescribeVerifiedAccessTrustProviders(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVerifiedAccessTrustProvidersResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVolumeAttribute

        /// <summary>
        /// Describes the specified attribute of the specified volume. You can specify only one
        /// attribute at a time.
        /// 
        ///  
        /// <para>
        /// For more information about EBS volumes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumes.html">Amazon
        /// EBS volumes</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVolumeAttribute service method.</param>
        /// 
        /// <returns>The response from the DescribeVolumeAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumeAttribute">REST API Reference for DescribeVolumeAttribute Operation</seealso>
        public virtual DescribeVolumeAttributeResponse DescribeVolumeAttribute(DescribeVolumeAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVolumeAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVolumeAttributeResponseUnmarshaller.Instance;

            return Invoke<DescribeVolumeAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVolumeAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVolumeAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVolumeAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumeAttribute">REST API Reference for DescribeVolumeAttribute Operation</seealso>
        public virtual IAsyncResult BeginDescribeVolumeAttribute(DescribeVolumeAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVolumeAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVolumeAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVolumeAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVolumeAttribute.</param>
        /// 
        /// <returns>Returns a  DescribeVolumeAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumeAttribute">REST API Reference for DescribeVolumeAttribute Operation</seealso>
        public virtual DescribeVolumeAttributeResponse EndDescribeVolumeAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVolumeAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVolumes

        /// <summary>
        /// Describes the specified EBS volumes or all of your EBS volumes.
        /// 
        ///  
        /// <para>
        /// If you are describing a long list of volumes, we recommend that you paginate the output
        /// to make the list more manageable. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination">Pagination</a>.
        /// </para>
        ///  
        /// <para>
        /// For more information about EBS volumes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumes.html">Amazon
        /// EBS volumes</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeVolumes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumes">REST API Reference for DescribeVolumes Operation</seealso>
        public virtual DescribeVolumesResponse DescribeVolumes()
        {
            return DescribeVolumes(new DescribeVolumesRequest());
        }

        /// <summary>
        /// Describes the specified EBS volumes or all of your EBS volumes.
        /// 
        ///  
        /// <para>
        /// If you are describing a long list of volumes, we recommend that you paginate the output
        /// to make the list more manageable. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination">Pagination</a>.
        /// </para>
        ///  
        /// <para>
        /// For more information about EBS volumes, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumes.html">Amazon
        /// EBS volumes</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVolumes service method.</param>
        /// 
        /// <returns>The response from the DescribeVolumes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumes">REST API Reference for DescribeVolumes Operation</seealso>
        public virtual DescribeVolumesResponse DescribeVolumes(DescribeVolumesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVolumesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVolumesResponseUnmarshaller.Instance;

            return Invoke<DescribeVolumesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVolumes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVolumes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVolumes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumes">REST API Reference for DescribeVolumes Operation</seealso>
        public virtual IAsyncResult BeginDescribeVolumes(DescribeVolumesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVolumesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVolumesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVolumes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVolumes.</param>
        /// 
        /// <returns>Returns a  DescribeVolumesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumes">REST API Reference for DescribeVolumes Operation</seealso>
        public virtual DescribeVolumesResponse EndDescribeVolumes(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVolumesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVolumesModifications

        /// <summary>
        /// Describes the most recent volume modification request for the specified EBS volumes.
        /// 
        ///  
        /// <para>
        /// If a volume has never been modified, some information in the output will be null.
        /// If a volume has been modified more than once, the output includes only the most recent
        /// modification request.
        /// </para>
        ///  
        /// <para>
        /// You can also use CloudWatch Events to check the status of a modification to an EBS
        /// volume. For information about CloudWatch Events, see the <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/">Amazon
        /// CloudWatch Events User Guide</a>. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-volume-modifications.html">Monitor
        /// the progress of volume modifications</a> in the <i>Amazon Elastic Compute Cloud User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVolumesModifications service method.</param>
        /// 
        /// <returns>The response from the DescribeVolumesModifications service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumesModifications">REST API Reference for DescribeVolumesModifications Operation</seealso>
        public virtual DescribeVolumesModificationsResponse DescribeVolumesModifications(DescribeVolumesModificationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVolumesModificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVolumesModificationsResponseUnmarshaller.Instance;

            return Invoke<DescribeVolumesModificationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVolumesModifications operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVolumesModifications operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVolumesModifications
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumesModifications">REST API Reference for DescribeVolumesModifications Operation</seealso>
        public virtual IAsyncResult BeginDescribeVolumesModifications(DescribeVolumesModificationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVolumesModificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVolumesModificationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVolumesModifications operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVolumesModifications.</param>
        /// 
        /// <returns>Returns a  DescribeVolumesModificationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumesModifications">REST API Reference for DescribeVolumesModifications Operation</seealso>
        public virtual DescribeVolumesModificationsResponse EndDescribeVolumesModifications(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVolumesModificationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVolumeStatus

        /// <summary>
        /// Describes the status of the specified volumes. Volume status provides the result of
        /// the checks performed on your volumes to determine events that can impair the performance
        /// of your volumes. The performance of a volume can be affected if an issue occurs on
        /// the volume's underlying host. If the volume's underlying host experiences a power
        /// outage or system issue, after the system is restored, there could be data inconsistencies
        /// on the volume. Volume events notify you if this occurs. Volume actions notify you
        /// if any action needs to be taken in response to the event.
        /// 
        ///  
        /// <para>
        /// The <code>DescribeVolumeStatus</code> operation provides the following information
        /// about the specified volumes:
        /// </para>
        ///  
        /// <para>
        ///  <i>Status</i>: Reflects the current status of the volume. The possible values are
        /// <code>ok</code>, <code>impaired</code> , <code>warning</code>, or <code>insufficient-data</code>.
        /// If all checks pass, the overall status of the volume is <code>ok</code>. If the check
        /// fails, the overall status is <code>impaired</code>. If the status is <code>insufficient-data</code>,
        /// then the checks might still be taking place on your volume at the time. We recommend
        /// that you retry the request. For more information about volume status, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-volume-status.html">Monitor
        /// the status of your volumes</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        ///  <i>Events</i>: Reflect the cause of a volume status and might require you to take
        /// action. For example, if your volume returns an <code>impaired</code> status, then
        /// the volume event might be <code>potential-data-inconsistency</code>. This means that
        /// your volume has been affected by an issue with the underlying host, has all I/O operations
        /// disabled, and might have inconsistent data.
        /// </para>
        ///  
        /// <para>
        ///  <i>Actions</i>: Reflect the actions you might have to take in response to an event.
        /// For example, if the status of the volume is <code>impaired</code> and the volume event
        /// shows <code>potential-data-inconsistency</code>, then the action shows <code>enable-volume-io</code>.
        /// This means that you may want to enable the I/O operations for the volume by calling
        /// the <a>EnableVolumeIO</a> action and then check the volume for data consistency.
        /// </para>
        ///  
        /// <para>
        /// Volume status is based on the volume status checks, and does not reflect the volume
        /// state. Therefore, volume status does not indicate volumes in the <code>error</code>
        /// state (for example, when a volume is incapable of accepting I/O.)
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeVolumeStatus service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumeStatus">REST API Reference for DescribeVolumeStatus Operation</seealso>
        public virtual DescribeVolumeStatusResponse DescribeVolumeStatus()
        {
            return DescribeVolumeStatus(new DescribeVolumeStatusRequest());
        }

        /// <summary>
        /// Describes the status of the specified volumes. Volume status provides the result of
        /// the checks performed on your volumes to determine events that can impair the performance
        /// of your volumes. The performance of a volume can be affected if an issue occurs on
        /// the volume's underlying host. If the volume's underlying host experiences a power
        /// outage or system issue, after the system is restored, there could be data inconsistencies
        /// on the volume. Volume events notify you if this occurs. Volume actions notify you
        /// if any action needs to be taken in response to the event.
        /// 
        ///  
        /// <para>
        /// The <code>DescribeVolumeStatus</code> operation provides the following information
        /// about the specified volumes:
        /// </para>
        ///  
        /// <para>
        ///  <i>Status</i>: Reflects the current status of the volume. The possible values are
        /// <code>ok</code>, <code>impaired</code> , <code>warning</code>, or <code>insufficient-data</code>.
        /// If all checks pass, the overall status of the volume is <code>ok</code>. If the check
        /// fails, the overall status is <code>impaired</code>. If the status is <code>insufficient-data</code>,
        /// then the checks might still be taking place on your volume at the time. We recommend
        /// that you retry the request. For more information about volume status, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-volume-status.html">Monitor
        /// the status of your volumes</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        ///  <i>Events</i>: Reflect the cause of a volume status and might require you to take
        /// action. For example, if your volume returns an <code>impaired</code> status, then
        /// the volume event might be <code>potential-data-inconsistency</code>. This means that
        /// your volume has been affected by an issue with the underlying host, has all I/O operations
        /// disabled, and might have inconsistent data.
        /// </para>
        ///  
        /// <para>
        ///  <i>Actions</i>: Reflect the actions you might have to take in response to an event.
        /// For example, if the status of the volume is <code>impaired</code> and the volume event
        /// shows <code>potential-data-inconsistency</code>, then the action shows <code>enable-volume-io</code>.
        /// This means that you may want to enable the I/O operations for the volume by calling
        /// the <a>EnableVolumeIO</a> action and then check the volume for data consistency.
        /// </para>
        ///  
        /// <para>
        /// Volume status is based on the volume status checks, and does not reflect the volume
        /// state. Therefore, volume status does not indicate volumes in the <code>error</code>
        /// state (for example, when a volume is incapable of accepting I/O.)
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVolumeStatus service method.</param>
        /// 
        /// <returns>The response from the DescribeVolumeStatus service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumeStatus">REST API Reference for DescribeVolumeStatus Operation</seealso>
        public virtual DescribeVolumeStatusResponse DescribeVolumeStatus(DescribeVolumeStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVolumeStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVolumeStatusResponseUnmarshaller.Instance;

            return Invoke<DescribeVolumeStatusResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVolumeStatus operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVolumeStatus operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVolumeStatus
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumeStatus">REST API Reference for DescribeVolumeStatus Operation</seealso>
        public virtual IAsyncResult BeginDescribeVolumeStatus(DescribeVolumeStatusRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVolumeStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVolumeStatusResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVolumeStatus operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVolumeStatus.</param>
        /// 
        /// <returns>Returns a  DescribeVolumeStatusResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVolumeStatus">REST API Reference for DescribeVolumeStatus Operation</seealso>
        public virtual DescribeVolumeStatusResponse EndDescribeVolumeStatus(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVolumeStatusResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcAttribute

        /// <summary>
        /// Describes the specified attribute of the specified VPC. You can specify only one attribute
        /// at a time.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcAttribute service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcAttribute">REST API Reference for DescribeVpcAttribute Operation</seealso>
        public virtual DescribeVpcAttributeResponse DescribeVpcAttribute(DescribeVpcAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcAttributeResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcAttribute">REST API Reference for DescribeVpcAttribute Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcAttribute(DescribeVpcAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcAttribute.</param>
        /// 
        /// <returns>Returns a  DescribeVpcAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcAttribute">REST API Reference for DescribeVpcAttribute Operation</seealso>
        public virtual DescribeVpcAttributeResponse EndDescribeVpcAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcClassicLink

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Describes the ClassicLink status of the specified VPCs.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcClassicLink service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcClassicLink service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcClassicLink">REST API Reference for DescribeVpcClassicLink Operation</seealso>
        public virtual DescribeVpcClassicLinkResponse DescribeVpcClassicLink(DescribeVpcClassicLinkRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcClassicLinkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcClassicLinkResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcClassicLinkResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcClassicLink operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcClassicLink operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcClassicLink
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcClassicLink">REST API Reference for DescribeVpcClassicLink Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcClassicLink(DescribeVpcClassicLinkRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcClassicLinkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcClassicLinkResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcClassicLink operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcClassicLink.</param>
        /// 
        /// <returns>Returns a  DescribeVpcClassicLinkResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcClassicLink">REST API Reference for DescribeVpcClassicLink Operation</seealso>
        public virtual DescribeVpcClassicLinkResponse EndDescribeVpcClassicLink(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcClassicLinkResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcClassicLinkDnsSupport

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Describes the ClassicLink DNS support status of one or more VPCs. If enabled, the
        /// DNS hostname of a linked EC2-Classic instance resolves to its private IP address when
        /// addressed from an instance in the VPC to which it's linked. Similarly, the DNS hostname
        /// of an instance in a VPC resolves to its private IP address when addressed from a linked
        /// EC2-Classic instance.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcClassicLinkDnsSupport service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcClassicLinkDnsSupport service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcClassicLinkDnsSupport">REST API Reference for DescribeVpcClassicLinkDnsSupport Operation</seealso>
        public virtual DescribeVpcClassicLinkDnsSupportResponse DescribeVpcClassicLinkDnsSupport(DescribeVpcClassicLinkDnsSupportRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcClassicLinkDnsSupportRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcClassicLinkDnsSupportResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcClassicLinkDnsSupportResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcClassicLinkDnsSupport operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcClassicLinkDnsSupport operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcClassicLinkDnsSupport
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcClassicLinkDnsSupport">REST API Reference for DescribeVpcClassicLinkDnsSupport Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcClassicLinkDnsSupport(DescribeVpcClassicLinkDnsSupportRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcClassicLinkDnsSupportRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcClassicLinkDnsSupportResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcClassicLinkDnsSupport operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcClassicLinkDnsSupport.</param>
        /// 
        /// <returns>Returns a  DescribeVpcClassicLinkDnsSupportResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcClassicLinkDnsSupport">REST API Reference for DescribeVpcClassicLinkDnsSupport Operation</seealso>
        public virtual DescribeVpcClassicLinkDnsSupportResponse EndDescribeVpcClassicLinkDnsSupport(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcClassicLinkDnsSupportResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcEndpointConnectionNotifications

        /// <summary>
        /// Describes the connection notifications for VPC endpoints and VPC endpoint services.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointConnectionNotifications service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcEndpointConnectionNotifications service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointConnectionNotifications">REST API Reference for DescribeVpcEndpointConnectionNotifications Operation</seealso>
        public virtual DescribeVpcEndpointConnectionNotificationsResponse DescribeVpcEndpointConnectionNotifications(DescribeVpcEndpointConnectionNotificationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointConnectionNotificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointConnectionNotificationsResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcEndpointConnectionNotificationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcEndpointConnectionNotifications operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointConnectionNotifications operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcEndpointConnectionNotifications
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointConnectionNotifications">REST API Reference for DescribeVpcEndpointConnectionNotifications Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcEndpointConnectionNotifications(DescribeVpcEndpointConnectionNotificationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointConnectionNotificationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointConnectionNotificationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcEndpointConnectionNotifications operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcEndpointConnectionNotifications.</param>
        /// 
        /// <returns>Returns a  DescribeVpcEndpointConnectionNotificationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointConnectionNotifications">REST API Reference for DescribeVpcEndpointConnectionNotifications Operation</seealso>
        public virtual DescribeVpcEndpointConnectionNotificationsResponse EndDescribeVpcEndpointConnectionNotifications(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcEndpointConnectionNotificationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcEndpointConnections

        /// <summary>
        /// Describes the VPC endpoint connections to your VPC endpoint services, including any
        /// endpoints that are pending your acceptance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointConnections service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcEndpointConnections service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointConnections">REST API Reference for DescribeVpcEndpointConnections Operation</seealso>
        public virtual DescribeVpcEndpointConnectionsResponse DescribeVpcEndpointConnections(DescribeVpcEndpointConnectionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointConnectionsResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcEndpointConnectionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcEndpointConnections operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointConnections operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcEndpointConnections
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointConnections">REST API Reference for DescribeVpcEndpointConnections Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcEndpointConnections(DescribeVpcEndpointConnectionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointConnectionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcEndpointConnections operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcEndpointConnections.</param>
        /// 
        /// <returns>Returns a  DescribeVpcEndpointConnectionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointConnections">REST API Reference for DescribeVpcEndpointConnections Operation</seealso>
        public virtual DescribeVpcEndpointConnectionsResponse EndDescribeVpcEndpointConnections(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcEndpointConnectionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcEndpoints

        /// <summary>
        /// Describes your VPC endpoints.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpoints service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcEndpoints service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpoints">REST API Reference for DescribeVpcEndpoints Operation</seealso>
        public virtual DescribeVpcEndpointsResponse DescribeVpcEndpoints(DescribeVpcEndpointsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointsResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcEndpointsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcEndpoints operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpoints operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcEndpoints
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpoints">REST API Reference for DescribeVpcEndpoints Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcEndpoints(DescribeVpcEndpointsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcEndpoints operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcEndpoints.</param>
        /// 
        /// <returns>Returns a  DescribeVpcEndpointsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpoints">REST API Reference for DescribeVpcEndpoints Operation</seealso>
        public virtual DescribeVpcEndpointsResponse EndDescribeVpcEndpoints(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcEndpointsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcEndpointServiceConfigurations

        /// <summary>
        /// Describes the VPC endpoint service configurations in your account (your services).
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointServiceConfigurations service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcEndpointServiceConfigurations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServiceConfigurations">REST API Reference for DescribeVpcEndpointServiceConfigurations Operation</seealso>
        public virtual DescribeVpcEndpointServiceConfigurationsResponse DescribeVpcEndpointServiceConfigurations(DescribeVpcEndpointServiceConfigurationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointServiceConfigurationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointServiceConfigurationsResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcEndpointServiceConfigurationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcEndpointServiceConfigurations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointServiceConfigurations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcEndpointServiceConfigurations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServiceConfigurations">REST API Reference for DescribeVpcEndpointServiceConfigurations Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcEndpointServiceConfigurations(DescribeVpcEndpointServiceConfigurationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointServiceConfigurationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointServiceConfigurationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcEndpointServiceConfigurations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcEndpointServiceConfigurations.</param>
        /// 
        /// <returns>Returns a  DescribeVpcEndpointServiceConfigurationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServiceConfigurations">REST API Reference for DescribeVpcEndpointServiceConfigurations Operation</seealso>
        public virtual DescribeVpcEndpointServiceConfigurationsResponse EndDescribeVpcEndpointServiceConfigurations(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcEndpointServiceConfigurationsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcEndpointServicePermissions

        /// <summary>
        /// Describes the principals (service consumers) that are permitted to discover your VPC
        /// endpoint service.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointServicePermissions service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcEndpointServicePermissions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServicePermissions">REST API Reference for DescribeVpcEndpointServicePermissions Operation</seealso>
        public virtual DescribeVpcEndpointServicePermissionsResponse DescribeVpcEndpointServicePermissions(DescribeVpcEndpointServicePermissionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointServicePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointServicePermissionsResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcEndpointServicePermissionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcEndpointServicePermissions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointServicePermissions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcEndpointServicePermissions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServicePermissions">REST API Reference for DescribeVpcEndpointServicePermissions Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcEndpointServicePermissions(DescribeVpcEndpointServicePermissionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointServicePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointServicePermissionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcEndpointServicePermissions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcEndpointServicePermissions.</param>
        /// 
        /// <returns>Returns a  DescribeVpcEndpointServicePermissionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServicePermissions">REST API Reference for DescribeVpcEndpointServicePermissions Operation</seealso>
        public virtual DescribeVpcEndpointServicePermissionsResponse EndDescribeVpcEndpointServicePermissions(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcEndpointServicePermissionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcEndpointServices

        /// <summary>
        /// Describes available services to which you can create a VPC endpoint.
        /// 
        ///  
        /// <para>
        /// When the service provider and the consumer have different accounts in multiple Availability
        /// Zones, and the consumer views the VPC endpoint service information, the response only
        /// includes the common Availability Zones. For example, when the service provider account
        /// uses <code>us-east-1a</code> and <code>us-east-1c</code> and the consumer uses <code>us-east-1a</code>
        /// and <code>us-east-1b</code>, the response includes the VPC endpoint services in the
        /// common Availability Zone, <code>us-east-1a</code>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointServices service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcEndpointServices service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServices">REST API Reference for DescribeVpcEndpointServices Operation</seealso>
        public virtual DescribeVpcEndpointServicesResponse DescribeVpcEndpointServices(DescribeVpcEndpointServicesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointServicesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointServicesResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcEndpointServicesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcEndpointServices operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcEndpointServices operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcEndpointServices
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServices">REST API Reference for DescribeVpcEndpointServices Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcEndpointServices(DescribeVpcEndpointServicesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcEndpointServicesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcEndpointServicesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcEndpointServices operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcEndpointServices.</param>
        /// 
        /// <returns>Returns a  DescribeVpcEndpointServicesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcEndpointServices">REST API Reference for DescribeVpcEndpointServices Operation</seealso>
        public virtual DescribeVpcEndpointServicesResponse EndDescribeVpcEndpointServices(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcEndpointServicesResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcPeeringConnections

        /// <summary>
        /// Describes one or more of your VPC peering connections.
        /// </summary>
        /// 
        /// <returns>The response from the DescribeVpcPeeringConnections service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcPeeringConnections">REST API Reference for DescribeVpcPeeringConnections Operation</seealso>
        public virtual DescribeVpcPeeringConnectionsResponse DescribeVpcPeeringConnections()
        {
            return DescribeVpcPeeringConnections(new DescribeVpcPeeringConnectionsRequest());
        }

        /// <summary>
        /// Describes one or more of your VPC peering connections.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcPeeringConnections service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcPeeringConnections service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcPeeringConnections">REST API Reference for DescribeVpcPeeringConnections Operation</seealso>
        public virtual DescribeVpcPeeringConnectionsResponse DescribeVpcPeeringConnections(DescribeVpcPeeringConnectionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcPeeringConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcPeeringConnectionsResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcPeeringConnectionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcPeeringConnections operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcPeeringConnections operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcPeeringConnections
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcPeeringConnections">REST API Reference for DescribeVpcPeeringConnections Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcPeeringConnections(DescribeVpcPeeringConnectionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcPeeringConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcPeeringConnectionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcPeeringConnections operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcPeeringConnections.</param>
        /// 
        /// <returns>Returns a  DescribeVpcPeeringConnectionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcPeeringConnections">REST API Reference for DescribeVpcPeeringConnections Operation</seealso>
        public virtual DescribeVpcPeeringConnectionsResponse EndDescribeVpcPeeringConnections(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcPeeringConnectionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpcs

        /// <summary>
        /// Describes one or more of your VPCs.
        /// </summary>
        /// 
        /// <returns>The response from the DescribeVpcs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcs">REST API Reference for DescribeVpcs Operation</seealso>
        public virtual DescribeVpcsResponse DescribeVpcs()
        {
            return DescribeVpcs(new DescribeVpcsRequest());
        }

        /// <summary>
        /// Describes one or more of your VPCs.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcs service method.</param>
        /// 
        /// <returns>The response from the DescribeVpcs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcs">REST API Reference for DescribeVpcs Operation</seealso>
        public virtual DescribeVpcsResponse DescribeVpcs(DescribeVpcsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcsResponseUnmarshaller.Instance;

            return Invoke<DescribeVpcsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpcs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpcs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpcs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcs">REST API Reference for DescribeVpcs Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpcs(DescribeVpcsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpcsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpcsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpcs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpcs.</param>
        /// 
        /// <returns>Returns a  DescribeVpcsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpcs">REST API Reference for DescribeVpcs Operation</seealso>
        public virtual DescribeVpcsResponse EndDescribeVpcs(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpcsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpnConnections

        /// <summary>
        /// Describes one or more of your VPN connections.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeVpnConnections service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnConnections">REST API Reference for DescribeVpnConnections Operation</seealso>
        public virtual DescribeVpnConnectionsResponse DescribeVpnConnections()
        {
            return DescribeVpnConnections(new DescribeVpnConnectionsRequest());
        }

        /// <summary>
        /// Describes one or more of your VPN connections.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpnConnections service method.</param>
        /// 
        /// <returns>The response from the DescribeVpnConnections service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnConnections">REST API Reference for DescribeVpnConnections Operation</seealso>
        public virtual DescribeVpnConnectionsResponse DescribeVpnConnections(DescribeVpnConnectionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpnConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpnConnectionsResponseUnmarshaller.Instance;

            return Invoke<DescribeVpnConnectionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpnConnections operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpnConnections operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpnConnections
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnConnections">REST API Reference for DescribeVpnConnections Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpnConnections(DescribeVpnConnectionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpnConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpnConnectionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpnConnections operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpnConnections.</param>
        /// 
        /// <returns>Returns a  DescribeVpnConnectionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnConnections">REST API Reference for DescribeVpnConnections Operation</seealso>
        public virtual DescribeVpnConnectionsResponse EndDescribeVpnConnections(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpnConnectionsResponse>(asyncResult);
        }

        #endregion
        
        #region  DescribeVpnGateways

        /// <summary>
        /// Describes one or more of your virtual private gateways.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// 
        /// <returns>The response from the DescribeVpnGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnGateways">REST API Reference for DescribeVpnGateways Operation</seealso>
        public virtual DescribeVpnGatewaysResponse DescribeVpnGateways()
        {
            return DescribeVpnGateways(new DescribeVpnGatewaysRequest());
        }

        /// <summary>
        /// Describes one or more of your virtual private gateways.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html">Amazon
        /// Web Services Site-to-Site VPN</a> in the <i>Amazon Web Services Site-to-Site VPN User
        /// Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpnGateways service method.</param>
        /// 
        /// <returns>The response from the DescribeVpnGateways service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnGateways">REST API Reference for DescribeVpnGateways Operation</seealso>
        public virtual DescribeVpnGatewaysResponse DescribeVpnGateways(DescribeVpnGatewaysRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpnGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpnGatewaysResponseUnmarshaller.Instance;

            return Invoke<DescribeVpnGatewaysResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DescribeVpnGateways operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DescribeVpnGateways operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeVpnGateways
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnGateways">REST API Reference for DescribeVpnGateways Operation</seealso>
        public virtual IAsyncResult BeginDescribeVpnGateways(DescribeVpnGatewaysRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DescribeVpnGatewaysRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DescribeVpnGatewaysResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DescribeVpnGateways operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDescribeVpnGateways.</param>
        /// 
        /// <returns>Returns a  DescribeVpnGatewaysResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DescribeVpnGateways">REST API Reference for DescribeVpnGateways Operation</seealso>
        public virtual DescribeVpnGatewaysResponse EndDescribeVpnGateways(IAsyncResult asyncResult)
        {
            return EndInvoke<DescribeVpnGatewaysResponse>(asyncResult);
        }

        #endregion
        
        #region  DetachClassicLinkVpc

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Unlinks (detaches) a linked EC2-Classic instance from a VPC. After the instance has
        /// been unlinked, the VPC security groups are no longer associated with it. An instance
        /// is automatically unlinked from a VPC when it's stopped.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DetachClassicLinkVpc service method.</param>
        /// 
        /// <returns>The response from the DetachClassicLinkVpc service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachClassicLinkVpc">REST API Reference for DetachClassicLinkVpc Operation</seealso>
        public virtual DetachClassicLinkVpcResponse DetachClassicLinkVpc(DetachClassicLinkVpcRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachClassicLinkVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachClassicLinkVpcResponseUnmarshaller.Instance;

            return Invoke<DetachClassicLinkVpcResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DetachClassicLinkVpc operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DetachClassicLinkVpc operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachClassicLinkVpc
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachClassicLinkVpc">REST API Reference for DetachClassicLinkVpc Operation</seealso>
        public virtual IAsyncResult BeginDetachClassicLinkVpc(DetachClassicLinkVpcRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachClassicLinkVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachClassicLinkVpcResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DetachClassicLinkVpc operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDetachClassicLinkVpc.</param>
        /// 
        /// <returns>Returns a  DetachClassicLinkVpcResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachClassicLinkVpc">REST API Reference for DetachClassicLinkVpc Operation</seealso>
        public virtual DetachClassicLinkVpcResponse EndDetachClassicLinkVpc(IAsyncResult asyncResult)
        {
            return EndInvoke<DetachClassicLinkVpcResponse>(asyncResult);
        }

        #endregion
        
        #region  DetachInternetGateway

        /// <summary>
        /// Detaches an internet gateway from a VPC, disabling connectivity between the internet
        /// and the VPC. The VPC must not contain any running instances with Elastic IP addresses
        /// or public IPv4 addresses.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DetachInternetGateway service method.</param>
        /// 
        /// <returns>The response from the DetachInternetGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachInternetGateway">REST API Reference for DetachInternetGateway Operation</seealso>
        public virtual DetachInternetGatewayResponse DetachInternetGateway(DetachInternetGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachInternetGatewayResponseUnmarshaller.Instance;

            return Invoke<DetachInternetGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DetachInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DetachInternetGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachInternetGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachInternetGateway">REST API Reference for DetachInternetGateway Operation</seealso>
        public virtual IAsyncResult BeginDetachInternetGateway(DetachInternetGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachInternetGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachInternetGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DetachInternetGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDetachInternetGateway.</param>
        /// 
        /// <returns>Returns a  DetachInternetGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachInternetGateway">REST API Reference for DetachInternetGateway Operation</seealso>
        public virtual DetachInternetGatewayResponse EndDetachInternetGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<DetachInternetGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DetachNetworkInterface

        /// <summary>
        /// Detaches a network interface from an instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DetachNetworkInterface service method.</param>
        /// 
        /// <returns>The response from the DetachNetworkInterface service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachNetworkInterface">REST API Reference for DetachNetworkInterface Operation</seealso>
        public virtual DetachNetworkInterfaceResponse DetachNetworkInterface(DetachNetworkInterfaceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachNetworkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachNetworkInterfaceResponseUnmarshaller.Instance;

            return Invoke<DetachNetworkInterfaceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DetachNetworkInterface operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DetachNetworkInterface operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachNetworkInterface
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachNetworkInterface">REST API Reference for DetachNetworkInterface Operation</seealso>
        public virtual IAsyncResult BeginDetachNetworkInterface(DetachNetworkInterfaceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachNetworkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachNetworkInterfaceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DetachNetworkInterface operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDetachNetworkInterface.</param>
        /// 
        /// <returns>Returns a  DetachNetworkInterfaceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachNetworkInterface">REST API Reference for DetachNetworkInterface Operation</seealso>
        public virtual DetachNetworkInterfaceResponse EndDetachNetworkInterface(IAsyncResult asyncResult)
        {
            return EndInvoke<DetachNetworkInterfaceResponse>(asyncResult);
        }

        #endregion
        
        #region  DetachVerifiedAccessTrustProvider

        /// <summary>
        /// Detaches the specified Amazon Web Services Verified Access trust provider from the
        /// specified Amazon Web Services Verified Access instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DetachVerifiedAccessTrustProvider service method.</param>
        /// 
        /// <returns>The response from the DetachVerifiedAccessTrustProvider service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVerifiedAccessTrustProvider">REST API Reference for DetachVerifiedAccessTrustProvider Operation</seealso>
        public virtual DetachVerifiedAccessTrustProviderResponse DetachVerifiedAccessTrustProvider(DetachVerifiedAccessTrustProviderRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return Invoke<DetachVerifiedAccessTrustProviderResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DetachVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DetachVerifiedAccessTrustProvider operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachVerifiedAccessTrustProvider
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVerifiedAccessTrustProvider">REST API Reference for DetachVerifiedAccessTrustProvider Operation</seealso>
        public virtual IAsyncResult BeginDetachVerifiedAccessTrustProvider(DetachVerifiedAccessTrustProviderRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DetachVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDetachVerifiedAccessTrustProvider.</param>
        /// 
        /// <returns>Returns a  DetachVerifiedAccessTrustProviderResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVerifiedAccessTrustProvider">REST API Reference for DetachVerifiedAccessTrustProvider Operation</seealso>
        public virtual DetachVerifiedAccessTrustProviderResponse EndDetachVerifiedAccessTrustProvider(IAsyncResult asyncResult)
        {
            return EndInvoke<DetachVerifiedAccessTrustProviderResponse>(asyncResult);
        }

        #endregion
        
        #region  DetachVolume

        /// <summary>
        /// Detaches an EBS volume from an instance. Make sure to unmount any file systems on
        /// the device within your operating system before detaching the volume. Failure to do
        /// so can result in the volume becoming stuck in the <code>busy</code> state while detaching.
        /// If this happens, detachment can be delayed indefinitely until you unmount the volume,
        /// force detachment, reboot the instance, or all three. If an EBS volume is the root
        /// device of an instance, it can't be detached while the instance is running. To detach
        /// the root volume, stop the instance first.
        /// 
        ///  
        /// <para>
        /// When a volume with an Amazon Web Services Marketplace product code is detached from
        /// an instance, the product code is no longer associated with the instance.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-detaching-volume.html">Detach
        /// an Amazon EBS volume</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DetachVolume service method.</param>
        /// 
        /// <returns>The response from the DetachVolume service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVolume">REST API Reference for DetachVolume Operation</seealso>
        public virtual DetachVolumeResponse DetachVolume(DetachVolumeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachVolumeResponseUnmarshaller.Instance;

            return Invoke<DetachVolumeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DetachVolume operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DetachVolume operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachVolume
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVolume">REST API Reference for DetachVolume Operation</seealso>
        public virtual IAsyncResult BeginDetachVolume(DetachVolumeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachVolumeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DetachVolume operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDetachVolume.</param>
        /// 
        /// <returns>Returns a  DetachVolumeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVolume">REST API Reference for DetachVolume Operation</seealso>
        public virtual DetachVolumeResponse EndDetachVolume(IAsyncResult asyncResult)
        {
            return EndInvoke<DetachVolumeResponse>(asyncResult);
        }

        #endregion
        
        #region  DetachVpnGateway

        /// <summary>
        /// Detaches a virtual private gateway from a VPC. You do this if you're planning to turn
        /// off the VPC and not use it anymore. You can confirm a virtual private gateway has
        /// been completely detached from a VPC by describing the virtual private gateway (any
        /// attachments to the virtual private gateway are also described).
        /// 
        ///  
        /// <para>
        /// You must wait for the attachment's state to switch to <code>detached</code> before
        /// you can delete the VPC or attach a different VPC to the virtual private gateway.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DetachVpnGateway service method.</param>
        /// 
        /// <returns>The response from the DetachVpnGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVpnGateway">REST API Reference for DetachVpnGateway Operation</seealso>
        public virtual DetachVpnGatewayResponse DetachVpnGateway(DetachVpnGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachVpnGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachVpnGatewayResponseUnmarshaller.Instance;

            return Invoke<DetachVpnGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DetachVpnGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DetachVpnGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDetachVpnGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVpnGateway">REST API Reference for DetachVpnGateway Operation</seealso>
        public virtual IAsyncResult BeginDetachVpnGateway(DetachVpnGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DetachVpnGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DetachVpnGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DetachVpnGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDetachVpnGateway.</param>
        /// 
        /// <returns>Returns a  DetachVpnGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DetachVpnGateway">REST API Reference for DetachVpnGateway Operation</seealso>
        public virtual DetachVpnGatewayResponse EndDetachVpnGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<DetachVpnGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableAddressTransfer

        /// <summary>
        /// Disables Elastic IP address transfer. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro">Transfer
        /// Elastic IP addresses</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableAddressTransfer service method.</param>
        /// 
        /// <returns>The response from the DisableAddressTransfer service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableAddressTransfer">REST API Reference for DisableAddressTransfer Operation</seealso>
        public virtual DisableAddressTransferResponse DisableAddressTransfer(DisableAddressTransferRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableAddressTransferRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableAddressTransferResponseUnmarshaller.Instance;

            return Invoke<DisableAddressTransferResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableAddressTransfer operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableAddressTransfer operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableAddressTransfer
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableAddressTransfer">REST API Reference for DisableAddressTransfer Operation</seealso>
        public virtual IAsyncResult BeginDisableAddressTransfer(DisableAddressTransferRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableAddressTransferRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableAddressTransferResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableAddressTransfer operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableAddressTransfer.</param>
        /// 
        /// <returns>Returns a  DisableAddressTransferResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableAddressTransfer">REST API Reference for DisableAddressTransfer Operation</seealso>
        public virtual DisableAddressTransferResponse EndDisableAddressTransfer(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableAddressTransferResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableAwsNetworkPerformanceMetricSubscription

        /// <summary>
        /// Disables Infrastructure Performance metric subscriptions.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableAwsNetworkPerformanceMetricSubscription service method.</param>
        /// 
        /// <returns>The response from the DisableAwsNetworkPerformanceMetricSubscription service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableAwsNetworkPerformanceMetricSubscription">REST API Reference for DisableAwsNetworkPerformanceMetricSubscription Operation</seealso>
        public virtual DisableAwsNetworkPerformanceMetricSubscriptionResponse DisableAwsNetworkPerformanceMetricSubscription(DisableAwsNetworkPerformanceMetricSubscriptionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableAwsNetworkPerformanceMetricSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableAwsNetworkPerformanceMetricSubscriptionResponseUnmarshaller.Instance;

            return Invoke<DisableAwsNetworkPerformanceMetricSubscriptionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableAwsNetworkPerformanceMetricSubscription operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableAwsNetworkPerformanceMetricSubscription operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableAwsNetworkPerformanceMetricSubscription
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableAwsNetworkPerformanceMetricSubscription">REST API Reference for DisableAwsNetworkPerformanceMetricSubscription Operation</seealso>
        public virtual IAsyncResult BeginDisableAwsNetworkPerformanceMetricSubscription(DisableAwsNetworkPerformanceMetricSubscriptionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableAwsNetworkPerformanceMetricSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableAwsNetworkPerformanceMetricSubscriptionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableAwsNetworkPerformanceMetricSubscription operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableAwsNetworkPerformanceMetricSubscription.</param>
        /// 
        /// <returns>Returns a  DisableAwsNetworkPerformanceMetricSubscriptionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableAwsNetworkPerformanceMetricSubscription">REST API Reference for DisableAwsNetworkPerformanceMetricSubscription Operation</seealso>
        public virtual DisableAwsNetworkPerformanceMetricSubscriptionResponse EndDisableAwsNetworkPerformanceMetricSubscription(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableAwsNetworkPerformanceMetricSubscriptionResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableEbsEncryptionByDefault

        /// <summary>
        /// Disables EBS encryption by default for your account in the current Region.
        /// 
        ///  
        /// <para>
        /// After you disable encryption by default, you can still create encrypted volumes by
        /// enabling encryption when you create each volume.
        /// </para>
        ///  
        /// <para>
        /// Disabling encryption by default does not change the encryption status of your existing
        /// volumes.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon
        /// EBS encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableEbsEncryptionByDefault service method.</param>
        /// 
        /// <returns>The response from the DisableEbsEncryptionByDefault service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableEbsEncryptionByDefault">REST API Reference for DisableEbsEncryptionByDefault Operation</seealso>
        public virtual DisableEbsEncryptionByDefaultResponse DisableEbsEncryptionByDefault(DisableEbsEncryptionByDefaultRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableEbsEncryptionByDefaultRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableEbsEncryptionByDefaultResponseUnmarshaller.Instance;

            return Invoke<DisableEbsEncryptionByDefaultResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableEbsEncryptionByDefault operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableEbsEncryptionByDefault operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableEbsEncryptionByDefault
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableEbsEncryptionByDefault">REST API Reference for DisableEbsEncryptionByDefault Operation</seealso>
        public virtual IAsyncResult BeginDisableEbsEncryptionByDefault(DisableEbsEncryptionByDefaultRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableEbsEncryptionByDefaultRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableEbsEncryptionByDefaultResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableEbsEncryptionByDefault operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableEbsEncryptionByDefault.</param>
        /// 
        /// <returns>Returns a  DisableEbsEncryptionByDefaultResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableEbsEncryptionByDefault">REST API Reference for DisableEbsEncryptionByDefault Operation</seealso>
        public virtual DisableEbsEncryptionByDefaultResponse EndDisableEbsEncryptionByDefault(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableEbsEncryptionByDefaultResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableFastLaunch

        /// <summary>
        /// Discontinue faster launching for a Windows AMI, and clean up existing pre-provisioned
        /// snapshots. When you disable faster launching, the AMI uses the standard launch process
        /// for each instance. All pre-provisioned snapshots must be removed before you can enable
        /// faster launching again.
        /// 
        ///  <note> 
        /// <para>
        /// To change these settings, you must own the AMI.
        /// </para>
        ///  </note>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableFastLaunch service method.</param>
        /// 
        /// <returns>The response from the DisableFastLaunch service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableFastLaunch">REST API Reference for DisableFastLaunch Operation</seealso>
        public virtual DisableFastLaunchResponse DisableFastLaunch(DisableFastLaunchRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableFastLaunchRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableFastLaunchResponseUnmarshaller.Instance;

            return Invoke<DisableFastLaunchResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableFastLaunch operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableFastLaunch operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableFastLaunch
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableFastLaunch">REST API Reference for DisableFastLaunch Operation</seealso>
        public virtual IAsyncResult BeginDisableFastLaunch(DisableFastLaunchRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableFastLaunchRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableFastLaunchResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableFastLaunch operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableFastLaunch.</param>
        /// 
        /// <returns>Returns a  DisableFastLaunchResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableFastLaunch">REST API Reference for DisableFastLaunch Operation</seealso>
        public virtual DisableFastLaunchResponse EndDisableFastLaunch(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableFastLaunchResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableFastSnapshotRestores

        /// <summary>
        /// Disables fast snapshot restores for the specified snapshots in the specified Availability
        /// Zones.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableFastSnapshotRestores service method.</param>
        /// 
        /// <returns>The response from the DisableFastSnapshotRestores service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableFastSnapshotRestores">REST API Reference for DisableFastSnapshotRestores Operation</seealso>
        public virtual DisableFastSnapshotRestoresResponse DisableFastSnapshotRestores(DisableFastSnapshotRestoresRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableFastSnapshotRestoresRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableFastSnapshotRestoresResponseUnmarshaller.Instance;

            return Invoke<DisableFastSnapshotRestoresResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableFastSnapshotRestores operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableFastSnapshotRestores operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableFastSnapshotRestores
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableFastSnapshotRestores">REST API Reference for DisableFastSnapshotRestores Operation</seealso>
        public virtual IAsyncResult BeginDisableFastSnapshotRestores(DisableFastSnapshotRestoresRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableFastSnapshotRestoresRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableFastSnapshotRestoresResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableFastSnapshotRestores operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableFastSnapshotRestores.</param>
        /// 
        /// <returns>Returns a  DisableFastSnapshotRestoresResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableFastSnapshotRestores">REST API Reference for DisableFastSnapshotRestores Operation</seealso>
        public virtual DisableFastSnapshotRestoresResponse EndDisableFastSnapshotRestores(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableFastSnapshotRestoresResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableImageDeprecation

        /// <summary>
        /// Cancels the deprecation of the specified AMI.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html">Deprecate
        /// an AMI</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableImageDeprecation service method.</param>
        /// 
        /// <returns>The response from the DisableImageDeprecation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableImageDeprecation">REST API Reference for DisableImageDeprecation Operation</seealso>
        public virtual DisableImageDeprecationResponse DisableImageDeprecation(DisableImageDeprecationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableImageDeprecationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableImageDeprecationResponseUnmarshaller.Instance;

            return Invoke<DisableImageDeprecationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableImageDeprecation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableImageDeprecation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableImageDeprecation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableImageDeprecation">REST API Reference for DisableImageDeprecation Operation</seealso>
        public virtual IAsyncResult BeginDisableImageDeprecation(DisableImageDeprecationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableImageDeprecationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableImageDeprecationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableImageDeprecation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableImageDeprecation.</param>
        /// 
        /// <returns>Returns a  DisableImageDeprecationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableImageDeprecation">REST API Reference for DisableImageDeprecation Operation</seealso>
        public virtual DisableImageDeprecationResponse EndDisableImageDeprecation(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableImageDeprecationResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableIpamOrganizationAdminAccount

        /// <summary>
        /// Disable the IPAM account. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html">Enable
        /// integration with Organizations</a> in the <i>Amazon VPC IPAM User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableIpamOrganizationAdminAccount service method.</param>
        /// 
        /// <returns>The response from the DisableIpamOrganizationAdminAccount service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableIpamOrganizationAdminAccount">REST API Reference for DisableIpamOrganizationAdminAccount Operation</seealso>
        public virtual DisableIpamOrganizationAdminAccountResponse DisableIpamOrganizationAdminAccount(DisableIpamOrganizationAdminAccountRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableIpamOrganizationAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableIpamOrganizationAdminAccountResponseUnmarshaller.Instance;

            return Invoke<DisableIpamOrganizationAdminAccountResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableIpamOrganizationAdminAccount operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableIpamOrganizationAdminAccount operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableIpamOrganizationAdminAccount
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableIpamOrganizationAdminAccount">REST API Reference for DisableIpamOrganizationAdminAccount Operation</seealso>
        public virtual IAsyncResult BeginDisableIpamOrganizationAdminAccount(DisableIpamOrganizationAdminAccountRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableIpamOrganizationAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableIpamOrganizationAdminAccountResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableIpamOrganizationAdminAccount operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableIpamOrganizationAdminAccount.</param>
        /// 
        /// <returns>Returns a  DisableIpamOrganizationAdminAccountResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableIpamOrganizationAdminAccount">REST API Reference for DisableIpamOrganizationAdminAccount Operation</seealso>
        public virtual DisableIpamOrganizationAdminAccountResponse EndDisableIpamOrganizationAdminAccount(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableIpamOrganizationAdminAccountResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableSerialConsoleAccess

        /// <summary>
        /// Disables access to the EC2 serial console of all instances for your account. By default,
        /// access to the EC2 serial console is disabled for your account. For more information,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configure-access-to-serial-console.html#serial-console-account-access">Manage
        /// account access to the EC2 serial console</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableSerialConsoleAccess service method.</param>
        /// 
        /// <returns>The response from the DisableSerialConsoleAccess service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableSerialConsoleAccess">REST API Reference for DisableSerialConsoleAccess Operation</seealso>
        public virtual DisableSerialConsoleAccessResponse DisableSerialConsoleAccess(DisableSerialConsoleAccessRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableSerialConsoleAccessRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableSerialConsoleAccessResponseUnmarshaller.Instance;

            return Invoke<DisableSerialConsoleAccessResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableSerialConsoleAccess operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableSerialConsoleAccess operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableSerialConsoleAccess
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableSerialConsoleAccess">REST API Reference for DisableSerialConsoleAccess Operation</seealso>
        public virtual IAsyncResult BeginDisableSerialConsoleAccess(DisableSerialConsoleAccessRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableSerialConsoleAccessRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableSerialConsoleAccessResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableSerialConsoleAccess operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableSerialConsoleAccess.</param>
        /// 
        /// <returns>Returns a  DisableSerialConsoleAccessResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableSerialConsoleAccess">REST API Reference for DisableSerialConsoleAccess Operation</seealso>
        public virtual DisableSerialConsoleAccessResponse EndDisableSerialConsoleAccess(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableSerialConsoleAccessResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableTransitGatewayRouteTablePropagation

        /// <summary>
        /// Disables the specified resource attachment from propagating routes to the specified
        /// propagation route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableTransitGatewayRouteTablePropagation service method.</param>
        /// 
        /// <returns>The response from the DisableTransitGatewayRouteTablePropagation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableTransitGatewayRouteTablePropagation">REST API Reference for DisableTransitGatewayRouteTablePropagation Operation</seealso>
        public virtual DisableTransitGatewayRouteTablePropagationResponse DisableTransitGatewayRouteTablePropagation(DisableTransitGatewayRouteTablePropagationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableTransitGatewayRouteTablePropagationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableTransitGatewayRouteTablePropagationResponseUnmarshaller.Instance;

            return Invoke<DisableTransitGatewayRouteTablePropagationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableTransitGatewayRouteTablePropagation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableTransitGatewayRouteTablePropagation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableTransitGatewayRouteTablePropagation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableTransitGatewayRouteTablePropagation">REST API Reference for DisableTransitGatewayRouteTablePropagation Operation</seealso>
        public virtual IAsyncResult BeginDisableTransitGatewayRouteTablePropagation(DisableTransitGatewayRouteTablePropagationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableTransitGatewayRouteTablePropagationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableTransitGatewayRouteTablePropagationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableTransitGatewayRouteTablePropagation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableTransitGatewayRouteTablePropagation.</param>
        /// 
        /// <returns>Returns a  DisableTransitGatewayRouteTablePropagationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableTransitGatewayRouteTablePropagation">REST API Reference for DisableTransitGatewayRouteTablePropagation Operation</seealso>
        public virtual DisableTransitGatewayRouteTablePropagationResponse EndDisableTransitGatewayRouteTablePropagation(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableTransitGatewayRouteTablePropagationResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableVgwRoutePropagation

        /// <summary>
        /// Disables a virtual private gateway (VGW) from propagating routes to a specified route
        /// table of a VPC.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableVgwRoutePropagation service method.</param>
        /// 
        /// <returns>The response from the DisableVgwRoutePropagation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVgwRoutePropagation">REST API Reference for DisableVgwRoutePropagation Operation</seealso>
        public virtual DisableVgwRoutePropagationResponse DisableVgwRoutePropagation(DisableVgwRoutePropagationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableVgwRoutePropagationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableVgwRoutePropagationResponseUnmarshaller.Instance;

            return Invoke<DisableVgwRoutePropagationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableVgwRoutePropagation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableVgwRoutePropagation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableVgwRoutePropagation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVgwRoutePropagation">REST API Reference for DisableVgwRoutePropagation Operation</seealso>
        public virtual IAsyncResult BeginDisableVgwRoutePropagation(DisableVgwRoutePropagationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableVgwRoutePropagationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableVgwRoutePropagationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableVgwRoutePropagation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableVgwRoutePropagation.</param>
        /// 
        /// <returns>Returns a  DisableVgwRoutePropagationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVgwRoutePropagation">REST API Reference for DisableVgwRoutePropagation Operation</seealso>
        public virtual DisableVgwRoutePropagationResponse EndDisableVgwRoutePropagation(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableVgwRoutePropagationResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableVpcClassicLink

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Disables ClassicLink for a VPC. You cannot disable ClassicLink for a VPC that has
        /// EC2-Classic instances linked to it.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableVpcClassicLink service method.</param>
        /// 
        /// <returns>The response from the DisableVpcClassicLink service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVpcClassicLink">REST API Reference for DisableVpcClassicLink Operation</seealso>
        public virtual DisableVpcClassicLinkResponse DisableVpcClassicLink(DisableVpcClassicLinkRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableVpcClassicLinkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableVpcClassicLinkResponseUnmarshaller.Instance;

            return Invoke<DisableVpcClassicLinkResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableVpcClassicLink operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableVpcClassicLink operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableVpcClassicLink
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVpcClassicLink">REST API Reference for DisableVpcClassicLink Operation</seealso>
        public virtual IAsyncResult BeginDisableVpcClassicLink(DisableVpcClassicLinkRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableVpcClassicLinkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableVpcClassicLinkResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableVpcClassicLink operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableVpcClassicLink.</param>
        /// 
        /// <returns>Returns a  DisableVpcClassicLinkResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVpcClassicLink">REST API Reference for DisableVpcClassicLink Operation</seealso>
        public virtual DisableVpcClassicLinkResponse EndDisableVpcClassicLink(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableVpcClassicLinkResponse>(asyncResult);
        }

        #endregion
        
        #region  DisableVpcClassicLinkDnsSupport

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Disables ClassicLink DNS support for a VPC. If disabled, DNS hostnames resolve to
        /// public IP addresses when addressed between a linked EC2-Classic instance and instances
        /// in the VPC to which it's linked.
        /// </para>
        ///  
        /// <para>
        /// You must specify a VPC ID in the request.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisableVpcClassicLinkDnsSupport service method.</param>
        /// 
        /// <returns>The response from the DisableVpcClassicLinkDnsSupport service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVpcClassicLinkDnsSupport">REST API Reference for DisableVpcClassicLinkDnsSupport Operation</seealso>
        public virtual DisableVpcClassicLinkDnsSupportResponse DisableVpcClassicLinkDnsSupport(DisableVpcClassicLinkDnsSupportRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableVpcClassicLinkDnsSupportRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableVpcClassicLinkDnsSupportResponseUnmarshaller.Instance;

            return Invoke<DisableVpcClassicLinkDnsSupportResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisableVpcClassicLinkDnsSupport operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisableVpcClassicLinkDnsSupport operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableVpcClassicLinkDnsSupport
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVpcClassicLinkDnsSupport">REST API Reference for DisableVpcClassicLinkDnsSupport Operation</seealso>
        public virtual IAsyncResult BeginDisableVpcClassicLinkDnsSupport(DisableVpcClassicLinkDnsSupportRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisableVpcClassicLinkDnsSupportRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisableVpcClassicLinkDnsSupportResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisableVpcClassicLinkDnsSupport operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisableVpcClassicLinkDnsSupport.</param>
        /// 
        /// <returns>Returns a  DisableVpcClassicLinkDnsSupportResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisableVpcClassicLinkDnsSupport">REST API Reference for DisableVpcClassicLinkDnsSupport Operation</seealso>
        public virtual DisableVpcClassicLinkDnsSupportResponse EndDisableVpcClassicLinkDnsSupport(IAsyncResult asyncResult)
        {
            return EndInvoke<DisableVpcClassicLinkDnsSupportResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateAddress

        /// <summary>
        /// Disassociates an Elastic IP address from the instance or network interface it's associated
        /// with.
        /// 
        ///  
        /// <para>
        /// This is an idempotent operation. If you perform the operation more than once, Amazon
        /// EC2 doesn't return an error.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateAddress service method.</param>
        /// 
        /// <returns>The response from the DisassociateAddress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateAddress">REST API Reference for DisassociateAddress Operation</seealso>
        public virtual DisassociateAddressResponse DisassociateAddress(DisassociateAddressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateAddressResponseUnmarshaller.Instance;

            return Invoke<DisassociateAddressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateAddress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateAddress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateAddress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateAddress">REST API Reference for DisassociateAddress Operation</seealso>
        public virtual IAsyncResult BeginDisassociateAddress(DisassociateAddressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateAddressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateAddress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateAddress.</param>
        /// 
        /// <returns>Returns a  DisassociateAddressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateAddress">REST API Reference for DisassociateAddress Operation</seealso>
        public virtual DisassociateAddressResponse EndDisassociateAddress(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateAddressResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateClientVpnTargetNetwork

        /// <summary>
        /// Disassociates a target network from the specified Client VPN endpoint. When you disassociate
        /// the last target network from a Client VPN, the following happens:
        /// 
        ///  <ul> <li> 
        /// <para>
        /// The route that was automatically added for the VPC is deleted
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// All active client connections are terminated
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// New client connections are disallowed
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// The Client VPN endpoint's status changes to <code>pending-associate</code> 
        /// </para>
        ///  </li> </ul>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateClientVpnTargetNetwork service method.</param>
        /// 
        /// <returns>The response from the DisassociateClientVpnTargetNetwork service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateClientVpnTargetNetwork">REST API Reference for DisassociateClientVpnTargetNetwork Operation</seealso>
        public virtual DisassociateClientVpnTargetNetworkResponse DisassociateClientVpnTargetNetwork(DisassociateClientVpnTargetNetworkRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateClientVpnTargetNetworkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateClientVpnTargetNetworkResponseUnmarshaller.Instance;

            return Invoke<DisassociateClientVpnTargetNetworkResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateClientVpnTargetNetwork operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateClientVpnTargetNetwork operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateClientVpnTargetNetwork
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateClientVpnTargetNetwork">REST API Reference for DisassociateClientVpnTargetNetwork Operation</seealso>
        public virtual IAsyncResult BeginDisassociateClientVpnTargetNetwork(DisassociateClientVpnTargetNetworkRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateClientVpnTargetNetworkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateClientVpnTargetNetworkResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateClientVpnTargetNetwork operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateClientVpnTargetNetwork.</param>
        /// 
        /// <returns>Returns a  DisassociateClientVpnTargetNetworkResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateClientVpnTargetNetwork">REST API Reference for DisassociateClientVpnTargetNetwork Operation</seealso>
        public virtual DisassociateClientVpnTargetNetworkResponse EndDisassociateClientVpnTargetNetwork(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateClientVpnTargetNetworkResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateEnclaveCertificateIamRole

        /// <summary>
        /// Disassociates an IAM role from an Certificate Manager (ACM) certificate. Disassociating
        /// an IAM role from an ACM certificate removes the Amazon S3 object that contains the
        /// certificate, certificate chain, and encrypted private key from the Amazon S3 bucket.
        /// It also revokes the IAM role's permission to use the KMS key used to encrypt the private
        /// key. This effectively revokes the role's permission to use the certificate.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateEnclaveCertificateIamRole service method.</param>
        /// 
        /// <returns>The response from the DisassociateEnclaveCertificateIamRole service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateEnclaveCertificateIamRole">REST API Reference for DisassociateEnclaveCertificateIamRole Operation</seealso>
        public virtual DisassociateEnclaveCertificateIamRoleResponse DisassociateEnclaveCertificateIamRole(DisassociateEnclaveCertificateIamRoleRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateEnclaveCertificateIamRoleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateEnclaveCertificateIamRoleResponseUnmarshaller.Instance;

            return Invoke<DisassociateEnclaveCertificateIamRoleResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateEnclaveCertificateIamRole operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateEnclaveCertificateIamRole operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateEnclaveCertificateIamRole
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateEnclaveCertificateIamRole">REST API Reference for DisassociateEnclaveCertificateIamRole Operation</seealso>
        public virtual IAsyncResult BeginDisassociateEnclaveCertificateIamRole(DisassociateEnclaveCertificateIamRoleRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateEnclaveCertificateIamRoleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateEnclaveCertificateIamRoleResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateEnclaveCertificateIamRole operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateEnclaveCertificateIamRole.</param>
        /// 
        /// <returns>Returns a  DisassociateEnclaveCertificateIamRoleResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateEnclaveCertificateIamRole">REST API Reference for DisassociateEnclaveCertificateIamRole Operation</seealso>
        public virtual DisassociateEnclaveCertificateIamRoleResponse EndDisassociateEnclaveCertificateIamRole(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateEnclaveCertificateIamRoleResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateIamInstanceProfile

        /// <summary>
        /// Disassociates an IAM instance profile from a running or stopped instance.
        /// 
        ///  
        /// <para>
        /// Use <a>DescribeIamInstanceProfileAssociations</a> to get the association ID.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateIamInstanceProfile service method.</param>
        /// 
        /// <returns>The response from the DisassociateIamInstanceProfile service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateIamInstanceProfile">REST API Reference for DisassociateIamInstanceProfile Operation</seealso>
        public virtual DisassociateIamInstanceProfileResponse DisassociateIamInstanceProfile(DisassociateIamInstanceProfileRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateIamInstanceProfileRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateIamInstanceProfileResponseUnmarshaller.Instance;

            return Invoke<DisassociateIamInstanceProfileResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateIamInstanceProfile operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateIamInstanceProfile operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateIamInstanceProfile
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateIamInstanceProfile">REST API Reference for DisassociateIamInstanceProfile Operation</seealso>
        public virtual IAsyncResult BeginDisassociateIamInstanceProfile(DisassociateIamInstanceProfileRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateIamInstanceProfileRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateIamInstanceProfileResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateIamInstanceProfile operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateIamInstanceProfile.</param>
        /// 
        /// <returns>Returns a  DisassociateIamInstanceProfileResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateIamInstanceProfile">REST API Reference for DisassociateIamInstanceProfile Operation</seealso>
        public virtual DisassociateIamInstanceProfileResponse EndDisassociateIamInstanceProfile(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateIamInstanceProfileResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateInstanceEventWindow

        /// <summary>
        /// Disassociates one or more targets from an event window.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
        /// event windows for scheduled events</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateInstanceEventWindow service method.</param>
        /// 
        /// <returns>The response from the DisassociateInstanceEventWindow service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateInstanceEventWindow">REST API Reference for DisassociateInstanceEventWindow Operation</seealso>
        public virtual DisassociateInstanceEventWindowResponse DisassociateInstanceEventWindow(DisassociateInstanceEventWindowRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateInstanceEventWindowResponseUnmarshaller.Instance;

            return Invoke<DisassociateInstanceEventWindowResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateInstanceEventWindow operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateInstanceEventWindow
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateInstanceEventWindow">REST API Reference for DisassociateInstanceEventWindow Operation</seealso>
        public virtual IAsyncResult BeginDisassociateInstanceEventWindow(DisassociateInstanceEventWindowRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateInstanceEventWindowResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateInstanceEventWindow.</param>
        /// 
        /// <returns>Returns a  DisassociateInstanceEventWindowResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateInstanceEventWindow">REST API Reference for DisassociateInstanceEventWindow Operation</seealso>
        public virtual DisassociateInstanceEventWindowResponse EndDisassociateInstanceEventWindow(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateInstanceEventWindowResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateIpamResourceDiscovery

        /// <summary>
        /// Disassociates a resource discovery from an Amazon VPC IPAM. A resource discovery is
        /// an IPAM component that enables IPAM to manage and monitor resources that belong to
        /// the owning account.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateIpamResourceDiscovery service method.</param>
        /// 
        /// <returns>The response from the DisassociateIpamResourceDiscovery service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateIpamResourceDiscovery">REST API Reference for DisassociateIpamResourceDiscovery Operation</seealso>
        public virtual DisassociateIpamResourceDiscoveryResponse DisassociateIpamResourceDiscovery(DisassociateIpamResourceDiscoveryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return Invoke<DisassociateIpamResourceDiscoveryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateIpamResourceDiscovery operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateIpamResourceDiscovery
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateIpamResourceDiscovery">REST API Reference for DisassociateIpamResourceDiscovery Operation</seealso>
        public virtual IAsyncResult BeginDisassociateIpamResourceDiscovery(DisassociateIpamResourceDiscoveryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateIpamResourceDiscovery.</param>
        /// 
        /// <returns>Returns a  DisassociateIpamResourceDiscoveryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateIpamResourceDiscovery">REST API Reference for DisassociateIpamResourceDiscovery Operation</seealso>
        public virtual DisassociateIpamResourceDiscoveryResponse EndDisassociateIpamResourceDiscovery(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateIpamResourceDiscoveryResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateNatGatewayAddress

        /// <summary>
        /// Disassociates secondary Elastic IP addresses (EIPs) from a public NAT gateway. You
        /// cannot disassociate your primary EIP. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-edit-secondary">Edit
        /// secondary IP address associations</a> in the <i>Amazon VPC User Guide</i>.
        /// 
        ///  
        /// <para>
        /// While disassociating is in progress, you cannot associate/disassociate additional
        /// EIPs while the connections are being drained. You are, however, allowed to delete
        /// the NAT gateway.
        /// </para>
        ///  
        /// <para>
        /// An EIP is released only at the end of MaxDrainDurationSeconds. It stays associated
        /// and supports the existing connections but does not support any new connections (new
        /// connections are distributed across the remaining associated EIPs). As the existing
        /// connections drain out, the EIPs (and the corresponding private IP addresses mapped
        /// to them) are released.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateNatGatewayAddress service method.</param>
        /// 
        /// <returns>The response from the DisassociateNatGatewayAddress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateNatGatewayAddress">REST API Reference for DisassociateNatGatewayAddress Operation</seealso>
        public virtual DisassociateNatGatewayAddressResponse DisassociateNatGatewayAddress(DisassociateNatGatewayAddressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateNatGatewayAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateNatGatewayAddressResponseUnmarshaller.Instance;

            return Invoke<DisassociateNatGatewayAddressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateNatGatewayAddress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateNatGatewayAddress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateNatGatewayAddress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateNatGatewayAddress">REST API Reference for DisassociateNatGatewayAddress Operation</seealso>
        public virtual IAsyncResult BeginDisassociateNatGatewayAddress(DisassociateNatGatewayAddressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateNatGatewayAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateNatGatewayAddressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateNatGatewayAddress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateNatGatewayAddress.</param>
        /// 
        /// <returns>Returns a  DisassociateNatGatewayAddressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateNatGatewayAddress">REST API Reference for DisassociateNatGatewayAddress Operation</seealso>
        public virtual DisassociateNatGatewayAddressResponse EndDisassociateNatGatewayAddress(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateNatGatewayAddressResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateRouteTable

        /// <summary>
        /// Disassociates a subnet or gateway from a route table.
        /// 
        ///  
        /// <para>
        /// After you perform this action, the subnet no longer uses the routes in the route table.
        /// Instead, it uses the routes in the VPC's main route table. For more information about
        /// route tables, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
        /// tables</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateRouteTable service method.</param>
        /// 
        /// <returns>The response from the DisassociateRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateRouteTable">REST API Reference for DisassociateRouteTable Operation</seealso>
        public virtual DisassociateRouteTableResponse DisassociateRouteTable(DisassociateRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateRouteTableResponseUnmarshaller.Instance;

            return Invoke<DisassociateRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateRouteTable">REST API Reference for DisassociateRouteTable Operation</seealso>
        public virtual IAsyncResult BeginDisassociateRouteTable(DisassociateRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateRouteTable.</param>
        /// 
        /// <returns>Returns a  DisassociateRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateRouteTable">REST API Reference for DisassociateRouteTable Operation</seealso>
        public virtual DisassociateRouteTableResponse EndDisassociateRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateSubnetCidrBlock

        /// <summary>
        /// Disassociates a CIDR block from a subnet. Currently, you can disassociate an IPv6
        /// CIDR block only. You must detach or delete all gateways and resources that are associated
        /// with the CIDR block before you can disassociate it.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateSubnetCidrBlock service method.</param>
        /// 
        /// <returns>The response from the DisassociateSubnetCidrBlock service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateSubnetCidrBlock">REST API Reference for DisassociateSubnetCidrBlock Operation</seealso>
        public virtual DisassociateSubnetCidrBlockResponse DisassociateSubnetCidrBlock(DisassociateSubnetCidrBlockRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateSubnetCidrBlockRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateSubnetCidrBlockResponseUnmarshaller.Instance;

            return Invoke<DisassociateSubnetCidrBlockResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateSubnetCidrBlock operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateSubnetCidrBlock operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateSubnetCidrBlock
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateSubnetCidrBlock">REST API Reference for DisassociateSubnetCidrBlock Operation</seealso>
        public virtual IAsyncResult BeginDisassociateSubnetCidrBlock(DisassociateSubnetCidrBlockRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateSubnetCidrBlockRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateSubnetCidrBlockResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateSubnetCidrBlock operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateSubnetCidrBlock.</param>
        /// 
        /// <returns>Returns a  DisassociateSubnetCidrBlockResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateSubnetCidrBlock">REST API Reference for DisassociateSubnetCidrBlock Operation</seealso>
        public virtual DisassociateSubnetCidrBlockResponse EndDisassociateSubnetCidrBlock(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateSubnetCidrBlockResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateTransitGatewayMulticastDomain

        /// <summary>
        /// Disassociates the specified subnets from the transit gateway multicast domain.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateTransitGatewayMulticastDomain service method.</param>
        /// 
        /// <returns>The response from the DisassociateTransitGatewayMulticastDomain service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayMulticastDomain">REST API Reference for DisassociateTransitGatewayMulticastDomain Operation</seealso>
        public virtual DisassociateTransitGatewayMulticastDomainResponse DisassociateTransitGatewayMulticastDomain(DisassociateTransitGatewayMulticastDomainRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateTransitGatewayMulticastDomainRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateTransitGatewayMulticastDomainResponseUnmarshaller.Instance;

            return Invoke<DisassociateTransitGatewayMulticastDomainResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateTransitGatewayMulticastDomain operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateTransitGatewayMulticastDomain operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateTransitGatewayMulticastDomain
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayMulticastDomain">REST API Reference for DisassociateTransitGatewayMulticastDomain Operation</seealso>
        public virtual IAsyncResult BeginDisassociateTransitGatewayMulticastDomain(DisassociateTransitGatewayMulticastDomainRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateTransitGatewayMulticastDomainRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateTransitGatewayMulticastDomainResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateTransitGatewayMulticastDomain operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateTransitGatewayMulticastDomain.</param>
        /// 
        /// <returns>Returns a  DisassociateTransitGatewayMulticastDomainResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayMulticastDomain">REST API Reference for DisassociateTransitGatewayMulticastDomain Operation</seealso>
        public virtual DisassociateTransitGatewayMulticastDomainResponse EndDisassociateTransitGatewayMulticastDomain(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateTransitGatewayMulticastDomainResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateTransitGatewayPolicyTable

        /// <summary>
        /// Removes the association between an an attachment and a policy table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateTransitGatewayPolicyTable service method.</param>
        /// 
        /// <returns>The response from the DisassociateTransitGatewayPolicyTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayPolicyTable">REST API Reference for DisassociateTransitGatewayPolicyTable Operation</seealso>
        public virtual DisassociateTransitGatewayPolicyTableResponse DisassociateTransitGatewayPolicyTable(DisassociateTransitGatewayPolicyTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateTransitGatewayPolicyTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateTransitGatewayPolicyTableResponseUnmarshaller.Instance;

            return Invoke<DisassociateTransitGatewayPolicyTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateTransitGatewayPolicyTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateTransitGatewayPolicyTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateTransitGatewayPolicyTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayPolicyTable">REST API Reference for DisassociateTransitGatewayPolicyTable Operation</seealso>
        public virtual IAsyncResult BeginDisassociateTransitGatewayPolicyTable(DisassociateTransitGatewayPolicyTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateTransitGatewayPolicyTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateTransitGatewayPolicyTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateTransitGatewayPolicyTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateTransitGatewayPolicyTable.</param>
        /// 
        /// <returns>Returns a  DisassociateTransitGatewayPolicyTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayPolicyTable">REST API Reference for DisassociateTransitGatewayPolicyTable Operation</seealso>
        public virtual DisassociateTransitGatewayPolicyTableResponse EndDisassociateTransitGatewayPolicyTable(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateTransitGatewayPolicyTableResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateTransitGatewayRouteTable

        /// <summary>
        /// Disassociates a resource attachment from a transit gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateTransitGatewayRouteTable service method.</param>
        /// 
        /// <returns>The response from the DisassociateTransitGatewayRouteTable service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayRouteTable">REST API Reference for DisassociateTransitGatewayRouteTable Operation</seealso>
        public virtual DisassociateTransitGatewayRouteTableResponse DisassociateTransitGatewayRouteTable(DisassociateTransitGatewayRouteTableRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateTransitGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateTransitGatewayRouteTableResponseUnmarshaller.Instance;

            return Invoke<DisassociateTransitGatewayRouteTableResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateTransitGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateTransitGatewayRouteTable operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateTransitGatewayRouteTable
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayRouteTable">REST API Reference for DisassociateTransitGatewayRouteTable Operation</seealso>
        public virtual IAsyncResult BeginDisassociateTransitGatewayRouteTable(DisassociateTransitGatewayRouteTableRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateTransitGatewayRouteTableRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateTransitGatewayRouteTableResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateTransitGatewayRouteTable operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateTransitGatewayRouteTable.</param>
        /// 
        /// <returns>Returns a  DisassociateTransitGatewayRouteTableResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTransitGatewayRouteTable">REST API Reference for DisassociateTransitGatewayRouteTable Operation</seealso>
        public virtual DisassociateTransitGatewayRouteTableResponse EndDisassociateTransitGatewayRouteTable(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateTransitGatewayRouteTableResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateTrunkInterface

        /// <summary>
        /// <note> 
        /// <para>
        /// This API action is currently in <b>limited preview only</b>. If you are interested
        /// in using this feature, contact your account manager.
        /// </para>
        ///  </note> 
        /// <para>
        /// Removes an association between a branch network interface with a trunk network interface.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateTrunkInterface service method.</param>
        /// 
        /// <returns>The response from the DisassociateTrunkInterface service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTrunkInterface">REST API Reference for DisassociateTrunkInterface Operation</seealso>
        public virtual DisassociateTrunkInterfaceResponse DisassociateTrunkInterface(DisassociateTrunkInterfaceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateTrunkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateTrunkInterfaceResponseUnmarshaller.Instance;

            return Invoke<DisassociateTrunkInterfaceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateTrunkInterface operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateTrunkInterface operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateTrunkInterface
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTrunkInterface">REST API Reference for DisassociateTrunkInterface Operation</seealso>
        public virtual IAsyncResult BeginDisassociateTrunkInterface(DisassociateTrunkInterfaceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateTrunkInterfaceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateTrunkInterfaceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateTrunkInterface operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateTrunkInterface.</param>
        /// 
        /// <returns>Returns a  DisassociateTrunkInterfaceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateTrunkInterface">REST API Reference for DisassociateTrunkInterface Operation</seealso>
        public virtual DisassociateTrunkInterfaceResponse EndDisassociateTrunkInterface(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateTrunkInterfaceResponse>(asyncResult);
        }

        #endregion
        
        #region  DisassociateVpcCidrBlock

        /// <summary>
        /// Disassociates a CIDR block from a VPC. To disassociate the CIDR block, you must specify
        /// its association ID. You can get the association ID by using <a>DescribeVpcs</a>. You
        /// must detach or delete all gateways and resources that are associated with the CIDR
        /// block before you can disassociate it. 
        /// 
        ///  
        /// <para>
        /// You cannot disassociate the CIDR block with which you originally created the VPC (the
        /// primary CIDR block).
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the DisassociateVpcCidrBlock service method.</param>
        /// 
        /// <returns>The response from the DisassociateVpcCidrBlock service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateVpcCidrBlock">REST API Reference for DisassociateVpcCidrBlock Operation</seealso>
        public virtual DisassociateVpcCidrBlockResponse DisassociateVpcCidrBlock(DisassociateVpcCidrBlockRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateVpcCidrBlockRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateVpcCidrBlockResponseUnmarshaller.Instance;

            return Invoke<DisassociateVpcCidrBlockResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the DisassociateVpcCidrBlock operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the DisassociateVpcCidrBlock operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateVpcCidrBlock
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateVpcCidrBlock">REST API Reference for DisassociateVpcCidrBlock Operation</seealso>
        public virtual IAsyncResult BeginDisassociateVpcCidrBlock(DisassociateVpcCidrBlockRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = DisassociateVpcCidrBlockRequestMarshaller.Instance;
            options.ResponseUnmarshaller = DisassociateVpcCidrBlockResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  DisassociateVpcCidrBlock operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginDisassociateVpcCidrBlock.</param>
        /// 
        /// <returns>Returns a  DisassociateVpcCidrBlockResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/DisassociateVpcCidrBlock">REST API Reference for DisassociateVpcCidrBlock Operation</seealso>
        public virtual DisassociateVpcCidrBlockResponse EndDisassociateVpcCidrBlock(IAsyncResult asyncResult)
        {
            return EndInvoke<DisassociateVpcCidrBlockResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableAddressTransfer

        /// <summary>
        /// Enables Elastic IP address transfer. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-eips.html#transfer-EIPs-intro">Transfer
        /// Elastic IP addresses</a> in the <i>Amazon Virtual Private Cloud User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableAddressTransfer service method.</param>
        /// 
        /// <returns>The response from the EnableAddressTransfer service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableAddressTransfer">REST API Reference for EnableAddressTransfer Operation</seealso>
        public virtual EnableAddressTransferResponse EnableAddressTransfer(EnableAddressTransferRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableAddressTransferRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableAddressTransferResponseUnmarshaller.Instance;

            return Invoke<EnableAddressTransferResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableAddressTransfer operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableAddressTransfer operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableAddressTransfer
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableAddressTransfer">REST API Reference for EnableAddressTransfer Operation</seealso>
        public virtual IAsyncResult BeginEnableAddressTransfer(EnableAddressTransferRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableAddressTransferRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableAddressTransferResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableAddressTransfer operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableAddressTransfer.</param>
        /// 
        /// <returns>Returns a  EnableAddressTransferResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableAddressTransfer">REST API Reference for EnableAddressTransfer Operation</seealso>
        public virtual EnableAddressTransferResponse EndEnableAddressTransfer(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableAddressTransferResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableAwsNetworkPerformanceMetricSubscription

        /// <summary>
        /// Enables Infrastructure Performance subscriptions.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableAwsNetworkPerformanceMetricSubscription service method.</param>
        /// 
        /// <returns>The response from the EnableAwsNetworkPerformanceMetricSubscription service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableAwsNetworkPerformanceMetricSubscription">REST API Reference for EnableAwsNetworkPerformanceMetricSubscription Operation</seealso>
        public virtual EnableAwsNetworkPerformanceMetricSubscriptionResponse EnableAwsNetworkPerformanceMetricSubscription(EnableAwsNetworkPerformanceMetricSubscriptionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableAwsNetworkPerformanceMetricSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableAwsNetworkPerformanceMetricSubscriptionResponseUnmarshaller.Instance;

            return Invoke<EnableAwsNetworkPerformanceMetricSubscriptionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableAwsNetworkPerformanceMetricSubscription operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableAwsNetworkPerformanceMetricSubscription operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableAwsNetworkPerformanceMetricSubscription
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableAwsNetworkPerformanceMetricSubscription">REST API Reference for EnableAwsNetworkPerformanceMetricSubscription Operation</seealso>
        public virtual IAsyncResult BeginEnableAwsNetworkPerformanceMetricSubscription(EnableAwsNetworkPerformanceMetricSubscriptionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableAwsNetworkPerformanceMetricSubscriptionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableAwsNetworkPerformanceMetricSubscriptionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableAwsNetworkPerformanceMetricSubscription operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableAwsNetworkPerformanceMetricSubscription.</param>
        /// 
        /// <returns>Returns a  EnableAwsNetworkPerformanceMetricSubscriptionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableAwsNetworkPerformanceMetricSubscription">REST API Reference for EnableAwsNetworkPerformanceMetricSubscription Operation</seealso>
        public virtual EnableAwsNetworkPerformanceMetricSubscriptionResponse EndEnableAwsNetworkPerformanceMetricSubscription(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableAwsNetworkPerformanceMetricSubscriptionResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableEbsEncryptionByDefault

        /// <summary>
        /// Enables EBS encryption by default for your account in the current Region.
        /// 
        ///  
        /// <para>
        /// After you enable encryption by default, the EBS volumes that you create are always
        /// encrypted, either using the default KMS key or the KMS key that you specified when
        /// you created each volume. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon
        /// EBS encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// You can specify the default KMS key for encryption by default using <a>ModifyEbsDefaultKmsKeyId</a>
        /// or <a>ResetEbsDefaultKmsKeyId</a>.
        /// </para>
        ///  
        /// <para>
        /// Enabling encryption by default has no effect on the encryption status of your existing
        /// volumes.
        /// </para>
        ///  
        /// <para>
        /// After you enable encryption by default, you can no longer launch instances using instance
        /// types that do not support encryption. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances">Supported
        /// instance types</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableEbsEncryptionByDefault service method.</param>
        /// 
        /// <returns>The response from the EnableEbsEncryptionByDefault service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableEbsEncryptionByDefault">REST API Reference for EnableEbsEncryptionByDefault Operation</seealso>
        public virtual EnableEbsEncryptionByDefaultResponse EnableEbsEncryptionByDefault(EnableEbsEncryptionByDefaultRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableEbsEncryptionByDefaultRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableEbsEncryptionByDefaultResponseUnmarshaller.Instance;

            return Invoke<EnableEbsEncryptionByDefaultResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableEbsEncryptionByDefault operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableEbsEncryptionByDefault operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableEbsEncryptionByDefault
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableEbsEncryptionByDefault">REST API Reference for EnableEbsEncryptionByDefault Operation</seealso>
        public virtual IAsyncResult BeginEnableEbsEncryptionByDefault(EnableEbsEncryptionByDefaultRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableEbsEncryptionByDefaultRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableEbsEncryptionByDefaultResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableEbsEncryptionByDefault operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableEbsEncryptionByDefault.</param>
        /// 
        /// <returns>Returns a  EnableEbsEncryptionByDefaultResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableEbsEncryptionByDefault">REST API Reference for EnableEbsEncryptionByDefault Operation</seealso>
        public virtual EnableEbsEncryptionByDefaultResponse EndEnableEbsEncryptionByDefault(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableEbsEncryptionByDefaultResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableFastLaunch

        /// <summary>
        /// When you enable faster launching for a Windows AMI, images are pre-provisioned, using
        /// snapshots to launch instances up to 65% faster. To create the optimized Windows image,
        /// Amazon EC2 launches an instance and runs through Sysprep steps, rebooting as required.
        /// Then it creates a set of reserved snapshots that are used for subsequent launches.
        /// The reserved snapshots are automatically replenished as they are used, depending on
        /// your settings for launch frequency.
        /// 
        ///  <note> 
        /// <para>
        /// To change these settings, you must own the AMI.
        /// </para>
        ///  </note>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableFastLaunch service method.</param>
        /// 
        /// <returns>The response from the EnableFastLaunch service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableFastLaunch">REST API Reference for EnableFastLaunch Operation</seealso>
        public virtual EnableFastLaunchResponse EnableFastLaunch(EnableFastLaunchRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableFastLaunchRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableFastLaunchResponseUnmarshaller.Instance;

            return Invoke<EnableFastLaunchResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableFastLaunch operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableFastLaunch operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableFastLaunch
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableFastLaunch">REST API Reference for EnableFastLaunch Operation</seealso>
        public virtual IAsyncResult BeginEnableFastLaunch(EnableFastLaunchRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableFastLaunchRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableFastLaunchResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableFastLaunch operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableFastLaunch.</param>
        /// 
        /// <returns>Returns a  EnableFastLaunchResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableFastLaunch">REST API Reference for EnableFastLaunch Operation</seealso>
        public virtual EnableFastLaunchResponse EndEnableFastLaunch(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableFastLaunchResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableFastSnapshotRestores

        /// <summary>
        /// Enables fast snapshot restores for the specified snapshots in the specified Availability
        /// Zones.
        /// 
        ///  
        /// <para>
        /// You get the full benefit of fast snapshot restores after they enter the <code>enabled</code>
        /// state. To get the current state of fast snapshot restores, use <a>DescribeFastSnapshotRestores</a>.
        /// To disable fast snapshot restores, use <a>DisableFastSnapshotRestores</a>.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-fast-snapshot-restore.html">Amazon
        /// EBS fast snapshot restore</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableFastSnapshotRestores service method.</param>
        /// 
        /// <returns>The response from the EnableFastSnapshotRestores service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableFastSnapshotRestores">REST API Reference for EnableFastSnapshotRestores Operation</seealso>
        public virtual EnableFastSnapshotRestoresResponse EnableFastSnapshotRestores(EnableFastSnapshotRestoresRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableFastSnapshotRestoresRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableFastSnapshotRestoresResponseUnmarshaller.Instance;

            return Invoke<EnableFastSnapshotRestoresResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableFastSnapshotRestores operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableFastSnapshotRestores operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableFastSnapshotRestores
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableFastSnapshotRestores">REST API Reference for EnableFastSnapshotRestores Operation</seealso>
        public virtual IAsyncResult BeginEnableFastSnapshotRestores(EnableFastSnapshotRestoresRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableFastSnapshotRestoresRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableFastSnapshotRestoresResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableFastSnapshotRestores operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableFastSnapshotRestores.</param>
        /// 
        /// <returns>Returns a  EnableFastSnapshotRestoresResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableFastSnapshotRestores">REST API Reference for EnableFastSnapshotRestores Operation</seealso>
        public virtual EnableFastSnapshotRestoresResponse EndEnableFastSnapshotRestores(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableFastSnapshotRestoresResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableImageDeprecation

        /// <summary>
        /// Enables deprecation of the specified AMI at the specified date and time.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-deprecate.html">Deprecate
        /// an AMI</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableImageDeprecation service method.</param>
        /// 
        /// <returns>The response from the EnableImageDeprecation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableImageDeprecation">REST API Reference for EnableImageDeprecation Operation</seealso>
        public virtual EnableImageDeprecationResponse EnableImageDeprecation(EnableImageDeprecationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableImageDeprecationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableImageDeprecationResponseUnmarshaller.Instance;

            return Invoke<EnableImageDeprecationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableImageDeprecation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableImageDeprecation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableImageDeprecation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableImageDeprecation">REST API Reference for EnableImageDeprecation Operation</seealso>
        public virtual IAsyncResult BeginEnableImageDeprecation(EnableImageDeprecationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableImageDeprecationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableImageDeprecationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableImageDeprecation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableImageDeprecation.</param>
        /// 
        /// <returns>Returns a  EnableImageDeprecationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableImageDeprecation">REST API Reference for EnableImageDeprecation Operation</seealso>
        public virtual EnableImageDeprecationResponse EndEnableImageDeprecation(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableImageDeprecationResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableIpamOrganizationAdminAccount

        /// <summary>
        /// Enable an Organizations member account as the IPAM admin account. You cannot select
        /// the Organizations management account as the IPAM admin account. For more information,
        /// see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html">Enable
        /// integration with Organizations</a> in the <i>Amazon VPC IPAM User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableIpamOrganizationAdminAccount service method.</param>
        /// 
        /// <returns>The response from the EnableIpamOrganizationAdminAccount service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableIpamOrganizationAdminAccount">REST API Reference for EnableIpamOrganizationAdminAccount Operation</seealso>
        public virtual EnableIpamOrganizationAdminAccountResponse EnableIpamOrganizationAdminAccount(EnableIpamOrganizationAdminAccountRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableIpamOrganizationAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableIpamOrganizationAdminAccountResponseUnmarshaller.Instance;

            return Invoke<EnableIpamOrganizationAdminAccountResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableIpamOrganizationAdminAccount operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableIpamOrganizationAdminAccount operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableIpamOrganizationAdminAccount
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableIpamOrganizationAdminAccount">REST API Reference for EnableIpamOrganizationAdminAccount Operation</seealso>
        public virtual IAsyncResult BeginEnableIpamOrganizationAdminAccount(EnableIpamOrganizationAdminAccountRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableIpamOrganizationAdminAccountRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableIpamOrganizationAdminAccountResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableIpamOrganizationAdminAccount operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableIpamOrganizationAdminAccount.</param>
        /// 
        /// <returns>Returns a  EnableIpamOrganizationAdminAccountResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableIpamOrganizationAdminAccount">REST API Reference for EnableIpamOrganizationAdminAccount Operation</seealso>
        public virtual EnableIpamOrganizationAdminAccountResponse EndEnableIpamOrganizationAdminAccount(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableIpamOrganizationAdminAccountResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableReachabilityAnalyzerOrganizationSharing

        /// <summary>
        /// Establishes a trust relationship between Reachability Analyzer and Organizations.
        /// This operation must be performed by the management account for the organization.
        /// 
        ///  
        /// <para>
        /// After you establish a trust relationship, a user in the management account or a delegated
        /// administrator account can run a cross-account analysis using resources from the member
        /// accounts.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableReachabilityAnalyzerOrganizationSharing service method.</param>
        /// 
        /// <returns>The response from the EnableReachabilityAnalyzerOrganizationSharing service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableReachabilityAnalyzerOrganizationSharing">REST API Reference for EnableReachabilityAnalyzerOrganizationSharing Operation</seealso>
        public virtual EnableReachabilityAnalyzerOrganizationSharingResponse EnableReachabilityAnalyzerOrganizationSharing(EnableReachabilityAnalyzerOrganizationSharingRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableReachabilityAnalyzerOrganizationSharingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableReachabilityAnalyzerOrganizationSharingResponseUnmarshaller.Instance;

            return Invoke<EnableReachabilityAnalyzerOrganizationSharingResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableReachabilityAnalyzerOrganizationSharing operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableReachabilityAnalyzerOrganizationSharing operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableReachabilityAnalyzerOrganizationSharing
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableReachabilityAnalyzerOrganizationSharing">REST API Reference for EnableReachabilityAnalyzerOrganizationSharing Operation</seealso>
        public virtual IAsyncResult BeginEnableReachabilityAnalyzerOrganizationSharing(EnableReachabilityAnalyzerOrganizationSharingRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableReachabilityAnalyzerOrganizationSharingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableReachabilityAnalyzerOrganizationSharingResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableReachabilityAnalyzerOrganizationSharing operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableReachabilityAnalyzerOrganizationSharing.</param>
        /// 
        /// <returns>Returns a  EnableReachabilityAnalyzerOrganizationSharingResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableReachabilityAnalyzerOrganizationSharing">REST API Reference for EnableReachabilityAnalyzerOrganizationSharing Operation</seealso>
        public virtual EnableReachabilityAnalyzerOrganizationSharingResponse EndEnableReachabilityAnalyzerOrganizationSharing(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableReachabilityAnalyzerOrganizationSharingResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableSerialConsoleAccess

        /// <summary>
        /// Enables access to the EC2 serial console of all instances for your account. By default,
        /// access to the EC2 serial console is disabled for your account. For more information,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configure-access-to-serial-console.html#serial-console-account-access">Manage
        /// account access to the EC2 serial console</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableSerialConsoleAccess service method.</param>
        /// 
        /// <returns>The response from the EnableSerialConsoleAccess service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableSerialConsoleAccess">REST API Reference for EnableSerialConsoleAccess Operation</seealso>
        public virtual EnableSerialConsoleAccessResponse EnableSerialConsoleAccess(EnableSerialConsoleAccessRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableSerialConsoleAccessRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableSerialConsoleAccessResponseUnmarshaller.Instance;

            return Invoke<EnableSerialConsoleAccessResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableSerialConsoleAccess operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableSerialConsoleAccess operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableSerialConsoleAccess
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableSerialConsoleAccess">REST API Reference for EnableSerialConsoleAccess Operation</seealso>
        public virtual IAsyncResult BeginEnableSerialConsoleAccess(EnableSerialConsoleAccessRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableSerialConsoleAccessRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableSerialConsoleAccessResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableSerialConsoleAccess operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableSerialConsoleAccess.</param>
        /// 
        /// <returns>Returns a  EnableSerialConsoleAccessResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableSerialConsoleAccess">REST API Reference for EnableSerialConsoleAccess Operation</seealso>
        public virtual EnableSerialConsoleAccessResponse EndEnableSerialConsoleAccess(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableSerialConsoleAccessResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableTransitGatewayRouteTablePropagation

        /// <summary>
        /// Enables the specified attachment to propagate routes to the specified propagation
        /// route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableTransitGatewayRouteTablePropagation service method.</param>
        /// 
        /// <returns>The response from the EnableTransitGatewayRouteTablePropagation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableTransitGatewayRouteTablePropagation">REST API Reference for EnableTransitGatewayRouteTablePropagation Operation</seealso>
        public virtual EnableTransitGatewayRouteTablePropagationResponse EnableTransitGatewayRouteTablePropagation(EnableTransitGatewayRouteTablePropagationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableTransitGatewayRouteTablePropagationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableTransitGatewayRouteTablePropagationResponseUnmarshaller.Instance;

            return Invoke<EnableTransitGatewayRouteTablePropagationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableTransitGatewayRouteTablePropagation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableTransitGatewayRouteTablePropagation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableTransitGatewayRouteTablePropagation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableTransitGatewayRouteTablePropagation">REST API Reference for EnableTransitGatewayRouteTablePropagation Operation</seealso>
        public virtual IAsyncResult BeginEnableTransitGatewayRouteTablePropagation(EnableTransitGatewayRouteTablePropagationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableTransitGatewayRouteTablePropagationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableTransitGatewayRouteTablePropagationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableTransitGatewayRouteTablePropagation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableTransitGatewayRouteTablePropagation.</param>
        /// 
        /// <returns>Returns a  EnableTransitGatewayRouteTablePropagationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableTransitGatewayRouteTablePropagation">REST API Reference for EnableTransitGatewayRouteTablePropagation Operation</seealso>
        public virtual EnableTransitGatewayRouteTablePropagationResponse EndEnableTransitGatewayRouteTablePropagation(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableTransitGatewayRouteTablePropagationResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableVgwRoutePropagation

        /// <summary>
        /// Enables a virtual private gateway (VGW) to propagate routes to the specified route
        /// table of a VPC.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableVgwRoutePropagation service method.</param>
        /// 
        /// <returns>The response from the EnableVgwRoutePropagation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVgwRoutePropagation">REST API Reference for EnableVgwRoutePropagation Operation</seealso>
        public virtual EnableVgwRoutePropagationResponse EnableVgwRoutePropagation(EnableVgwRoutePropagationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableVgwRoutePropagationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableVgwRoutePropagationResponseUnmarshaller.Instance;

            return Invoke<EnableVgwRoutePropagationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableVgwRoutePropagation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableVgwRoutePropagation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableVgwRoutePropagation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVgwRoutePropagation">REST API Reference for EnableVgwRoutePropagation Operation</seealso>
        public virtual IAsyncResult BeginEnableVgwRoutePropagation(EnableVgwRoutePropagationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableVgwRoutePropagationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableVgwRoutePropagationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableVgwRoutePropagation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableVgwRoutePropagation.</param>
        /// 
        /// <returns>Returns a  EnableVgwRoutePropagationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVgwRoutePropagation">REST API Reference for EnableVgwRoutePropagation Operation</seealso>
        public virtual EnableVgwRoutePropagationResponse EndEnableVgwRoutePropagation(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableVgwRoutePropagationResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableVolumeIO

        /// <summary>
        /// Enables I/O operations for a volume that had I/O operations disabled because the data
        /// on the volume was potentially inconsistent.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableVolumeIO service method.</param>
        /// 
        /// <returns>The response from the EnableVolumeIO service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVolumeIO">REST API Reference for EnableVolumeIO Operation</seealso>
        public virtual EnableVolumeIOResponse EnableVolumeIO(EnableVolumeIORequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableVolumeIORequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableVolumeIOResponseUnmarshaller.Instance;

            return Invoke<EnableVolumeIOResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableVolumeIO operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableVolumeIO operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableVolumeIO
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVolumeIO">REST API Reference for EnableVolumeIO Operation</seealso>
        public virtual IAsyncResult BeginEnableVolumeIO(EnableVolumeIORequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableVolumeIORequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableVolumeIOResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableVolumeIO operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableVolumeIO.</param>
        /// 
        /// <returns>Returns a  EnableVolumeIOResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVolumeIO">REST API Reference for EnableVolumeIO Operation</seealso>
        public virtual EnableVolumeIOResponse EndEnableVolumeIO(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableVolumeIOResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableVpcClassicLink

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Enables a VPC for ClassicLink. You can then link EC2-Classic instances to your ClassicLink-enabled
        /// VPC to allow communication over private IP addresses. You cannot enable your VPC for
        /// ClassicLink if any of your VPC route tables have existing routes for address ranges
        /// within the <code>10.0.0.0/8</code> IP address range, excluding local routes for VPCs
        /// in the <code>10.0.0.0/16</code> and <code>10.1.0.0/16</code> IP address ranges.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableVpcClassicLink service method.</param>
        /// 
        /// <returns>The response from the EnableVpcClassicLink service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVpcClassicLink">REST API Reference for EnableVpcClassicLink Operation</seealso>
        public virtual EnableVpcClassicLinkResponse EnableVpcClassicLink(EnableVpcClassicLinkRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableVpcClassicLinkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableVpcClassicLinkResponseUnmarshaller.Instance;

            return Invoke<EnableVpcClassicLinkResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableVpcClassicLink operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableVpcClassicLink operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableVpcClassicLink
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVpcClassicLink">REST API Reference for EnableVpcClassicLink Operation</seealso>
        public virtual IAsyncResult BeginEnableVpcClassicLink(EnableVpcClassicLinkRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableVpcClassicLinkRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableVpcClassicLinkResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableVpcClassicLink operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableVpcClassicLink.</param>
        /// 
        /// <returns>Returns a  EnableVpcClassicLinkResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVpcClassicLink">REST API Reference for EnableVpcClassicLink Operation</seealso>
        public virtual EnableVpcClassicLinkResponse EndEnableVpcClassicLink(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableVpcClassicLinkResponse>(asyncResult);
        }

        #endregion
        
        #region  EnableVpcClassicLinkDnsSupport

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Enables a VPC to support DNS hostname resolution for ClassicLink. If enabled, the
        /// DNS hostname of a linked EC2-Classic instance resolves to its private IP address when
        /// addressed from an instance in the VPC to which it's linked. Similarly, the DNS hostname
        /// of an instance in a VPC resolves to its private IP address when addressed from a linked
        /// EC2-Classic instance.
        /// </para>
        ///  
        /// <para>
        /// You must specify a VPC ID in the request.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the EnableVpcClassicLinkDnsSupport service method.</param>
        /// 
        /// <returns>The response from the EnableVpcClassicLinkDnsSupport service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVpcClassicLinkDnsSupport">REST API Reference for EnableVpcClassicLinkDnsSupport Operation</seealso>
        public virtual EnableVpcClassicLinkDnsSupportResponse EnableVpcClassicLinkDnsSupport(EnableVpcClassicLinkDnsSupportRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableVpcClassicLinkDnsSupportRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableVpcClassicLinkDnsSupportResponseUnmarshaller.Instance;

            return Invoke<EnableVpcClassicLinkDnsSupportResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the EnableVpcClassicLinkDnsSupport operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the EnableVpcClassicLinkDnsSupport operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableVpcClassicLinkDnsSupport
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVpcClassicLinkDnsSupport">REST API Reference for EnableVpcClassicLinkDnsSupport Operation</seealso>
        public virtual IAsyncResult BeginEnableVpcClassicLinkDnsSupport(EnableVpcClassicLinkDnsSupportRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = EnableVpcClassicLinkDnsSupportRequestMarshaller.Instance;
            options.ResponseUnmarshaller = EnableVpcClassicLinkDnsSupportResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  EnableVpcClassicLinkDnsSupport operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginEnableVpcClassicLinkDnsSupport.</param>
        /// 
        /// <returns>Returns a  EnableVpcClassicLinkDnsSupportResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/EnableVpcClassicLinkDnsSupport">REST API Reference for EnableVpcClassicLinkDnsSupport Operation</seealso>
        public virtual EnableVpcClassicLinkDnsSupportResponse EndEnableVpcClassicLinkDnsSupport(IAsyncResult asyncResult)
        {
            return EndInvoke<EnableVpcClassicLinkDnsSupportResponse>(asyncResult);
        }

        #endregion
        
        #region  ExportClientVpnClientCertificateRevocationList

        /// <summary>
        /// Downloads the client certificate revocation list for the specified Client VPN endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ExportClientVpnClientCertificateRevocationList service method.</param>
        /// 
        /// <returns>The response from the ExportClientVpnClientCertificateRevocationList service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportClientVpnClientCertificateRevocationList">REST API Reference for ExportClientVpnClientCertificateRevocationList Operation</seealso>
        public virtual ExportClientVpnClientCertificateRevocationListResponse ExportClientVpnClientCertificateRevocationList(ExportClientVpnClientCertificateRevocationListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ExportClientVpnClientCertificateRevocationListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ExportClientVpnClientCertificateRevocationListResponseUnmarshaller.Instance;

            return Invoke<ExportClientVpnClientCertificateRevocationListResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ExportClientVpnClientCertificateRevocationList operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ExportClientVpnClientCertificateRevocationList operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExportClientVpnClientCertificateRevocationList
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportClientVpnClientCertificateRevocationList">REST API Reference for ExportClientVpnClientCertificateRevocationList Operation</seealso>
        public virtual IAsyncResult BeginExportClientVpnClientCertificateRevocationList(ExportClientVpnClientCertificateRevocationListRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ExportClientVpnClientCertificateRevocationListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ExportClientVpnClientCertificateRevocationListResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ExportClientVpnClientCertificateRevocationList operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginExportClientVpnClientCertificateRevocationList.</param>
        /// 
        /// <returns>Returns a  ExportClientVpnClientCertificateRevocationListResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportClientVpnClientCertificateRevocationList">REST API Reference for ExportClientVpnClientCertificateRevocationList Operation</seealso>
        public virtual ExportClientVpnClientCertificateRevocationListResponse EndExportClientVpnClientCertificateRevocationList(IAsyncResult asyncResult)
        {
            return EndInvoke<ExportClientVpnClientCertificateRevocationListResponse>(asyncResult);
        }

        #endregion
        
        #region  ExportClientVpnClientConfiguration

        /// <summary>
        /// Downloads the contents of the Client VPN endpoint configuration file for the specified
        /// Client VPN endpoint. The Client VPN endpoint configuration file includes the Client
        /// VPN endpoint and certificate information clients need to establish a connection with
        /// the Client VPN endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ExportClientVpnClientConfiguration service method.</param>
        /// 
        /// <returns>The response from the ExportClientVpnClientConfiguration service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportClientVpnClientConfiguration">REST API Reference for ExportClientVpnClientConfiguration Operation</seealso>
        public virtual ExportClientVpnClientConfigurationResponse ExportClientVpnClientConfiguration(ExportClientVpnClientConfigurationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ExportClientVpnClientConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ExportClientVpnClientConfigurationResponseUnmarshaller.Instance;

            return Invoke<ExportClientVpnClientConfigurationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ExportClientVpnClientConfiguration operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ExportClientVpnClientConfiguration operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExportClientVpnClientConfiguration
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportClientVpnClientConfiguration">REST API Reference for ExportClientVpnClientConfiguration Operation</seealso>
        public virtual IAsyncResult BeginExportClientVpnClientConfiguration(ExportClientVpnClientConfigurationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ExportClientVpnClientConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ExportClientVpnClientConfigurationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ExportClientVpnClientConfiguration operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginExportClientVpnClientConfiguration.</param>
        /// 
        /// <returns>Returns a  ExportClientVpnClientConfigurationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportClientVpnClientConfiguration">REST API Reference for ExportClientVpnClientConfiguration Operation</seealso>
        public virtual ExportClientVpnClientConfigurationResponse EndExportClientVpnClientConfiguration(IAsyncResult asyncResult)
        {
            return EndInvoke<ExportClientVpnClientConfigurationResponse>(asyncResult);
        }

        #endregion
        
        #region  ExportImage

        /// <summary>
        /// Exports an Amazon Machine Image (AMI) to a VM file. For more information, see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport_image.html">Exporting
        /// a VM directly from an Amazon Machine Image (AMI)</a> in the <i>VM Import/Export User
        /// Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ExportImage service method.</param>
        /// 
        /// <returns>The response from the ExportImage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportImage">REST API Reference for ExportImage Operation</seealso>
        public virtual ExportImageResponse ExportImage(ExportImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ExportImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ExportImageResponseUnmarshaller.Instance;

            return Invoke<ExportImageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ExportImage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ExportImage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExportImage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportImage">REST API Reference for ExportImage Operation</seealso>
        public virtual IAsyncResult BeginExportImage(ExportImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ExportImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ExportImageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ExportImage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginExportImage.</param>
        /// 
        /// <returns>Returns a  ExportImageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportImage">REST API Reference for ExportImage Operation</seealso>
        public virtual ExportImageResponse EndExportImage(IAsyncResult asyncResult)
        {
            return EndInvoke<ExportImageResponse>(asyncResult);
        }

        #endregion
        
        #region  ExportTransitGatewayRoutes

        /// <summary>
        /// Exports routes from the specified transit gateway route table to the specified S3
        /// bucket. By default, all routes are exported. Alternatively, you can filter by CIDR
        /// range.
        /// 
        ///  
        /// <para>
        /// The routes are saved to the specified bucket in a JSON file. For more information,
        /// see <a href="https://docs.aws.amazon.com/vpc/latest/tgw/tgw-route-tables.html#tgw-export-route-tables">Export
        /// Route Tables to Amazon S3</a> in <i>Transit Gateways</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ExportTransitGatewayRoutes service method.</param>
        /// 
        /// <returns>The response from the ExportTransitGatewayRoutes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportTransitGatewayRoutes">REST API Reference for ExportTransitGatewayRoutes Operation</seealso>
        public virtual ExportTransitGatewayRoutesResponse ExportTransitGatewayRoutes(ExportTransitGatewayRoutesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ExportTransitGatewayRoutesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ExportTransitGatewayRoutesResponseUnmarshaller.Instance;

            return Invoke<ExportTransitGatewayRoutesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ExportTransitGatewayRoutes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ExportTransitGatewayRoutes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndExportTransitGatewayRoutes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportTransitGatewayRoutes">REST API Reference for ExportTransitGatewayRoutes Operation</seealso>
        public virtual IAsyncResult BeginExportTransitGatewayRoutes(ExportTransitGatewayRoutesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ExportTransitGatewayRoutesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ExportTransitGatewayRoutesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ExportTransitGatewayRoutes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginExportTransitGatewayRoutes.</param>
        /// 
        /// <returns>Returns a  ExportTransitGatewayRoutesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ExportTransitGatewayRoutes">REST API Reference for ExportTransitGatewayRoutes Operation</seealso>
        public virtual ExportTransitGatewayRoutesResponse EndExportTransitGatewayRoutes(IAsyncResult asyncResult)
        {
            return EndInvoke<ExportTransitGatewayRoutesResponse>(asyncResult);
        }

        #endregion
        
        #region  GetAssociatedEnclaveCertificateIamRoles

        /// <summary>
        /// Returns the IAM roles that are associated with the specified ACM (ACM) certificate.
        /// It also returns the name of the Amazon S3 bucket and the Amazon S3 object key where
        /// the certificate, certificate chain, and encrypted private key bundle are stored, and
        /// the ARN of the KMS key that's used to encrypt the private key.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetAssociatedEnclaveCertificateIamRoles service method.</param>
        /// 
        /// <returns>The response from the GetAssociatedEnclaveCertificateIamRoles service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAssociatedEnclaveCertificateIamRoles">REST API Reference for GetAssociatedEnclaveCertificateIamRoles Operation</seealso>
        public virtual GetAssociatedEnclaveCertificateIamRolesResponse GetAssociatedEnclaveCertificateIamRoles(GetAssociatedEnclaveCertificateIamRolesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAssociatedEnclaveCertificateIamRolesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAssociatedEnclaveCertificateIamRolesResponseUnmarshaller.Instance;

            return Invoke<GetAssociatedEnclaveCertificateIamRolesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetAssociatedEnclaveCertificateIamRoles operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetAssociatedEnclaveCertificateIamRoles operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAssociatedEnclaveCertificateIamRoles
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAssociatedEnclaveCertificateIamRoles">REST API Reference for GetAssociatedEnclaveCertificateIamRoles Operation</seealso>
        public virtual IAsyncResult BeginGetAssociatedEnclaveCertificateIamRoles(GetAssociatedEnclaveCertificateIamRolesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAssociatedEnclaveCertificateIamRolesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAssociatedEnclaveCertificateIamRolesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetAssociatedEnclaveCertificateIamRoles operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetAssociatedEnclaveCertificateIamRoles.</param>
        /// 
        /// <returns>Returns a  GetAssociatedEnclaveCertificateIamRolesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAssociatedEnclaveCertificateIamRoles">REST API Reference for GetAssociatedEnclaveCertificateIamRoles Operation</seealso>
        public virtual GetAssociatedEnclaveCertificateIamRolesResponse EndGetAssociatedEnclaveCertificateIamRoles(IAsyncResult asyncResult)
        {
            return EndInvoke<GetAssociatedEnclaveCertificateIamRolesResponse>(asyncResult);
        }

        #endregion
        
        #region  GetAssociatedIpv6PoolCidrs

        /// <summary>
        /// Gets information about the IPv6 CIDR block associations for a specified IPv6 address
        /// pool.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetAssociatedIpv6PoolCidrs service method.</param>
        /// 
        /// <returns>The response from the GetAssociatedIpv6PoolCidrs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAssociatedIpv6PoolCidrs">REST API Reference for GetAssociatedIpv6PoolCidrs Operation</seealso>
        public virtual GetAssociatedIpv6PoolCidrsResponse GetAssociatedIpv6PoolCidrs(GetAssociatedIpv6PoolCidrsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAssociatedIpv6PoolCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAssociatedIpv6PoolCidrsResponseUnmarshaller.Instance;

            return Invoke<GetAssociatedIpv6PoolCidrsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetAssociatedIpv6PoolCidrs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetAssociatedIpv6PoolCidrs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAssociatedIpv6PoolCidrs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAssociatedIpv6PoolCidrs">REST API Reference for GetAssociatedIpv6PoolCidrs Operation</seealso>
        public virtual IAsyncResult BeginGetAssociatedIpv6PoolCidrs(GetAssociatedIpv6PoolCidrsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAssociatedIpv6PoolCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAssociatedIpv6PoolCidrsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetAssociatedIpv6PoolCidrs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetAssociatedIpv6PoolCidrs.</param>
        /// 
        /// <returns>Returns a  GetAssociatedIpv6PoolCidrsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAssociatedIpv6PoolCidrs">REST API Reference for GetAssociatedIpv6PoolCidrs Operation</seealso>
        public virtual GetAssociatedIpv6PoolCidrsResponse EndGetAssociatedIpv6PoolCidrs(IAsyncResult asyncResult)
        {
            return EndInvoke<GetAssociatedIpv6PoolCidrsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetAwsNetworkPerformanceData

        /// <summary>
        /// Gets network performance data.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetAwsNetworkPerformanceData service method.</param>
        /// 
        /// <returns>The response from the GetAwsNetworkPerformanceData service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAwsNetworkPerformanceData">REST API Reference for GetAwsNetworkPerformanceData Operation</seealso>
        public virtual GetAwsNetworkPerformanceDataResponse GetAwsNetworkPerformanceData(GetAwsNetworkPerformanceDataRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAwsNetworkPerformanceDataRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAwsNetworkPerformanceDataResponseUnmarshaller.Instance;

            return Invoke<GetAwsNetworkPerformanceDataResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetAwsNetworkPerformanceData operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetAwsNetworkPerformanceData operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAwsNetworkPerformanceData
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAwsNetworkPerformanceData">REST API Reference for GetAwsNetworkPerformanceData Operation</seealso>
        public virtual IAsyncResult BeginGetAwsNetworkPerformanceData(GetAwsNetworkPerformanceDataRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetAwsNetworkPerformanceDataRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetAwsNetworkPerformanceDataResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetAwsNetworkPerformanceData operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetAwsNetworkPerformanceData.</param>
        /// 
        /// <returns>Returns a  GetAwsNetworkPerformanceDataResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetAwsNetworkPerformanceData">REST API Reference for GetAwsNetworkPerformanceData Operation</seealso>
        public virtual GetAwsNetworkPerformanceDataResponse EndGetAwsNetworkPerformanceData(IAsyncResult asyncResult)
        {
            return EndInvoke<GetAwsNetworkPerformanceDataResponse>(asyncResult);
        }

        #endregion
        
        #region  GetCapacityReservationUsage

        /// <summary>
        /// Gets usage information about a Capacity Reservation. If the Capacity Reservation is
        /// shared, it shows usage information for the Capacity Reservation owner and each Amazon
        /// Web Services account that is currently using the shared capacity. If the Capacity
        /// Reservation is not shared, it shows only the Capacity Reservation owner's usage.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetCapacityReservationUsage service method.</param>
        /// 
        /// <returns>The response from the GetCapacityReservationUsage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCapacityReservationUsage">REST API Reference for GetCapacityReservationUsage Operation</seealso>
        public virtual GetCapacityReservationUsageResponse GetCapacityReservationUsage(GetCapacityReservationUsageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetCapacityReservationUsageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetCapacityReservationUsageResponseUnmarshaller.Instance;

            return Invoke<GetCapacityReservationUsageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetCapacityReservationUsage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetCapacityReservationUsage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCapacityReservationUsage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCapacityReservationUsage">REST API Reference for GetCapacityReservationUsage Operation</seealso>
        public virtual IAsyncResult BeginGetCapacityReservationUsage(GetCapacityReservationUsageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetCapacityReservationUsageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetCapacityReservationUsageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetCapacityReservationUsage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetCapacityReservationUsage.</param>
        /// 
        /// <returns>Returns a  GetCapacityReservationUsageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCapacityReservationUsage">REST API Reference for GetCapacityReservationUsage Operation</seealso>
        public virtual GetCapacityReservationUsageResponse EndGetCapacityReservationUsage(IAsyncResult asyncResult)
        {
            return EndInvoke<GetCapacityReservationUsageResponse>(asyncResult);
        }

        #endregion
        
        #region  GetCoipPoolUsage

        /// <summary>
        /// Describes the allocations from the specified customer-owned address pool.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetCoipPoolUsage service method.</param>
        /// 
        /// <returns>The response from the GetCoipPoolUsage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCoipPoolUsage">REST API Reference for GetCoipPoolUsage Operation</seealso>
        public virtual GetCoipPoolUsageResponse GetCoipPoolUsage(GetCoipPoolUsageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetCoipPoolUsageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetCoipPoolUsageResponseUnmarshaller.Instance;

            return Invoke<GetCoipPoolUsageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetCoipPoolUsage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetCoipPoolUsage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetCoipPoolUsage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCoipPoolUsage">REST API Reference for GetCoipPoolUsage Operation</seealso>
        public virtual IAsyncResult BeginGetCoipPoolUsage(GetCoipPoolUsageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetCoipPoolUsageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetCoipPoolUsageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetCoipPoolUsage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetCoipPoolUsage.</param>
        /// 
        /// <returns>Returns a  GetCoipPoolUsageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetCoipPoolUsage">REST API Reference for GetCoipPoolUsage Operation</seealso>
        public virtual GetCoipPoolUsageResponse EndGetCoipPoolUsage(IAsyncResult asyncResult)
        {
            return EndInvoke<GetCoipPoolUsageResponse>(asyncResult);
        }

        #endregion
        
        #region  GetConsoleOutput

        /// <summary>
        /// Gets the console output for the specified instance. For Linux instances, the instance
        /// console output displays the exact console output that would normally be displayed
        /// on a physical monitor attached to a computer. For Windows instances, the instance
        /// console output includes the last three system event log errors.
        /// 
        ///  
        /// <para>
        /// By default, the console output returns buffered information that was posted shortly
        /// after an instance transition state (start, stop, reboot, or terminate). This information
        /// is available for at least one hour after the most recent post. Only the most recent
        /// 64 KB of console output is available.
        /// </para>
        ///  
        /// <para>
        /// You can optionally retrieve the latest serial console output at any time during the
        /// instance lifecycle. This option is supported on instance types that use the Nitro
        /// hypervisor.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html#instance-console-console-output">Instance
        /// console output</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetConsoleOutput service method.</param>
        /// 
        /// <returns>The response from the GetConsoleOutput service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetConsoleOutput">REST API Reference for GetConsoleOutput Operation</seealso>
        public virtual GetConsoleOutputResponse GetConsoleOutput(GetConsoleOutputRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetConsoleOutputRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetConsoleOutputResponseUnmarshaller.Instance;

            return Invoke<GetConsoleOutputResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetConsoleOutput operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetConsoleOutput operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetConsoleOutput
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetConsoleOutput">REST API Reference for GetConsoleOutput Operation</seealso>
        public virtual IAsyncResult BeginGetConsoleOutput(GetConsoleOutputRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetConsoleOutputRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetConsoleOutputResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetConsoleOutput operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetConsoleOutput.</param>
        /// 
        /// <returns>Returns a  GetConsoleOutputResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetConsoleOutput">REST API Reference for GetConsoleOutput Operation</seealso>
        public virtual GetConsoleOutputResponse EndGetConsoleOutput(IAsyncResult asyncResult)
        {
            return EndInvoke<GetConsoleOutputResponse>(asyncResult);
        }

        #endregion
        
        #region  GetConsoleScreenshot

        /// <summary>
        /// Retrieve a JPG-format screenshot of a running instance to help with troubleshooting.
        /// 
        ///  
        /// <para>
        /// The returned content is Base64-encoded.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetConsoleScreenshot service method.</param>
        /// 
        /// <returns>The response from the GetConsoleScreenshot service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetConsoleScreenshot">REST API Reference for GetConsoleScreenshot Operation</seealso>
        public virtual GetConsoleScreenshotResponse GetConsoleScreenshot(GetConsoleScreenshotRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetConsoleScreenshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetConsoleScreenshotResponseUnmarshaller.Instance;

            return Invoke<GetConsoleScreenshotResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetConsoleScreenshot operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetConsoleScreenshot operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetConsoleScreenshot
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetConsoleScreenshot">REST API Reference for GetConsoleScreenshot Operation</seealso>
        public virtual IAsyncResult BeginGetConsoleScreenshot(GetConsoleScreenshotRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetConsoleScreenshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetConsoleScreenshotResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetConsoleScreenshot operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetConsoleScreenshot.</param>
        /// 
        /// <returns>Returns a  GetConsoleScreenshotResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetConsoleScreenshot">REST API Reference for GetConsoleScreenshot Operation</seealso>
        public virtual GetConsoleScreenshotResponse EndGetConsoleScreenshot(IAsyncResult asyncResult)
        {
            return EndInvoke<GetConsoleScreenshotResponse>(asyncResult);
        }

        #endregion
        
        #region  GetDefaultCreditSpecification

        /// <summary>
        /// Describes the default credit option for CPU usage of a burstable performance instance
        /// family.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html">Burstable
        /// performance instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetDefaultCreditSpecification service method.</param>
        /// 
        /// <returns>The response from the GetDefaultCreditSpecification service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetDefaultCreditSpecification">REST API Reference for GetDefaultCreditSpecification Operation</seealso>
        public virtual GetDefaultCreditSpecificationResponse GetDefaultCreditSpecification(GetDefaultCreditSpecificationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetDefaultCreditSpecificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetDefaultCreditSpecificationResponseUnmarshaller.Instance;

            return Invoke<GetDefaultCreditSpecificationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetDefaultCreditSpecification operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetDefaultCreditSpecification operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDefaultCreditSpecification
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetDefaultCreditSpecification">REST API Reference for GetDefaultCreditSpecification Operation</seealso>
        public virtual IAsyncResult BeginGetDefaultCreditSpecification(GetDefaultCreditSpecificationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetDefaultCreditSpecificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetDefaultCreditSpecificationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetDefaultCreditSpecification operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetDefaultCreditSpecification.</param>
        /// 
        /// <returns>Returns a  GetDefaultCreditSpecificationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetDefaultCreditSpecification">REST API Reference for GetDefaultCreditSpecification Operation</seealso>
        public virtual GetDefaultCreditSpecificationResponse EndGetDefaultCreditSpecification(IAsyncResult asyncResult)
        {
            return EndInvoke<GetDefaultCreditSpecificationResponse>(asyncResult);
        }

        #endregion
        
        #region  GetEbsDefaultKmsKeyId

        /// <summary>
        /// Describes the default KMS key for EBS encryption by default for your account in this
        /// Region. You can change the default KMS key for encryption by default using <a>ModifyEbsDefaultKmsKeyId</a>
        /// or <a>ResetEbsDefaultKmsKeyId</a>.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon
        /// EBS encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetEbsDefaultKmsKeyId service method.</param>
        /// 
        /// <returns>The response from the GetEbsDefaultKmsKeyId service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetEbsDefaultKmsKeyId">REST API Reference for GetEbsDefaultKmsKeyId Operation</seealso>
        public virtual GetEbsDefaultKmsKeyIdResponse GetEbsDefaultKmsKeyId(GetEbsDefaultKmsKeyIdRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetEbsDefaultKmsKeyIdRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetEbsDefaultKmsKeyIdResponseUnmarshaller.Instance;

            return Invoke<GetEbsDefaultKmsKeyIdResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetEbsDefaultKmsKeyId operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetEbsDefaultKmsKeyId operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetEbsDefaultKmsKeyId
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetEbsDefaultKmsKeyId">REST API Reference for GetEbsDefaultKmsKeyId Operation</seealso>
        public virtual IAsyncResult BeginGetEbsDefaultKmsKeyId(GetEbsDefaultKmsKeyIdRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetEbsDefaultKmsKeyIdRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetEbsDefaultKmsKeyIdResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetEbsDefaultKmsKeyId operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetEbsDefaultKmsKeyId.</param>
        /// 
        /// <returns>Returns a  GetEbsDefaultKmsKeyIdResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetEbsDefaultKmsKeyId">REST API Reference for GetEbsDefaultKmsKeyId Operation</seealso>
        public virtual GetEbsDefaultKmsKeyIdResponse EndGetEbsDefaultKmsKeyId(IAsyncResult asyncResult)
        {
            return EndInvoke<GetEbsDefaultKmsKeyIdResponse>(asyncResult);
        }

        #endregion
        
        #region  GetEbsEncryptionByDefault

        /// <summary>
        /// Describes whether EBS encryption by default is enabled for your account in the current
        /// Region.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon
        /// EBS encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetEbsEncryptionByDefault service method.</param>
        /// 
        /// <returns>The response from the GetEbsEncryptionByDefault service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetEbsEncryptionByDefault">REST API Reference for GetEbsEncryptionByDefault Operation</seealso>
        public virtual GetEbsEncryptionByDefaultResponse GetEbsEncryptionByDefault(GetEbsEncryptionByDefaultRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetEbsEncryptionByDefaultRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetEbsEncryptionByDefaultResponseUnmarshaller.Instance;

            return Invoke<GetEbsEncryptionByDefaultResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetEbsEncryptionByDefault operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetEbsEncryptionByDefault operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetEbsEncryptionByDefault
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetEbsEncryptionByDefault">REST API Reference for GetEbsEncryptionByDefault Operation</seealso>
        public virtual IAsyncResult BeginGetEbsEncryptionByDefault(GetEbsEncryptionByDefaultRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetEbsEncryptionByDefaultRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetEbsEncryptionByDefaultResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetEbsEncryptionByDefault operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetEbsEncryptionByDefault.</param>
        /// 
        /// <returns>Returns a  GetEbsEncryptionByDefaultResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetEbsEncryptionByDefault">REST API Reference for GetEbsEncryptionByDefault Operation</seealso>
        public virtual GetEbsEncryptionByDefaultResponse EndGetEbsEncryptionByDefault(IAsyncResult asyncResult)
        {
            return EndInvoke<GetEbsEncryptionByDefaultResponse>(asyncResult);
        }

        #endregion
        
        #region  GetFlowLogsIntegrationTemplate

        /// <summary>
        /// Generates a CloudFormation template that streamlines and automates the integration
        /// of VPC flow logs with Amazon Athena. This make it easier for you to query and gain
        /// insights from VPC flow logs data. Based on the information that you provide, we configure
        /// resources in the template to do the following:
        /// 
        ///  <ul> <li> 
        /// <para>
        /// Create a table in Athena that maps fields to a custom log format
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Create a Lambda function that updates the table with new partitions on a daily, weekly,
        /// or monthly basis
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Create a table partitioned between two timestamps in the past
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Create a set of named queries in Athena that you can use to get started quickly
        /// </para>
        ///  </li> </ul> <note> 
        /// <para>
        ///  <code>GetFlowLogsIntegrationTemplate</code> does not support integration between
        /// Amazon Web Services Transit Gateway Flow Logs and Amazon Athena.
        /// </para>
        ///  </note>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetFlowLogsIntegrationTemplate service method.</param>
        /// 
        /// <returns>The response from the GetFlowLogsIntegrationTemplate service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetFlowLogsIntegrationTemplate">REST API Reference for GetFlowLogsIntegrationTemplate Operation</seealso>
        public virtual GetFlowLogsIntegrationTemplateResponse GetFlowLogsIntegrationTemplate(GetFlowLogsIntegrationTemplateRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetFlowLogsIntegrationTemplateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetFlowLogsIntegrationTemplateResponseUnmarshaller.Instance;

            return Invoke<GetFlowLogsIntegrationTemplateResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetFlowLogsIntegrationTemplate operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetFlowLogsIntegrationTemplate operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetFlowLogsIntegrationTemplate
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetFlowLogsIntegrationTemplate">REST API Reference for GetFlowLogsIntegrationTemplate Operation</seealso>
        public virtual IAsyncResult BeginGetFlowLogsIntegrationTemplate(GetFlowLogsIntegrationTemplateRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetFlowLogsIntegrationTemplateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetFlowLogsIntegrationTemplateResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetFlowLogsIntegrationTemplate operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetFlowLogsIntegrationTemplate.</param>
        /// 
        /// <returns>Returns a  GetFlowLogsIntegrationTemplateResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetFlowLogsIntegrationTemplate">REST API Reference for GetFlowLogsIntegrationTemplate Operation</seealso>
        public virtual GetFlowLogsIntegrationTemplateResponse EndGetFlowLogsIntegrationTemplate(IAsyncResult asyncResult)
        {
            return EndInvoke<GetFlowLogsIntegrationTemplateResponse>(asyncResult);
        }

        #endregion
        
        #region  GetGroupsForCapacityReservation

        /// <summary>
        /// Lists the resource groups to which a Capacity Reservation has been added.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetGroupsForCapacityReservation service method.</param>
        /// 
        /// <returns>The response from the GetGroupsForCapacityReservation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetGroupsForCapacityReservation">REST API Reference for GetGroupsForCapacityReservation Operation</seealso>
        public virtual GetGroupsForCapacityReservationResponse GetGroupsForCapacityReservation(GetGroupsForCapacityReservationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetGroupsForCapacityReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetGroupsForCapacityReservationResponseUnmarshaller.Instance;

            return Invoke<GetGroupsForCapacityReservationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetGroupsForCapacityReservation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetGroupsForCapacityReservation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetGroupsForCapacityReservation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetGroupsForCapacityReservation">REST API Reference for GetGroupsForCapacityReservation Operation</seealso>
        public virtual IAsyncResult BeginGetGroupsForCapacityReservation(GetGroupsForCapacityReservationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetGroupsForCapacityReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetGroupsForCapacityReservationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetGroupsForCapacityReservation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetGroupsForCapacityReservation.</param>
        /// 
        /// <returns>Returns a  GetGroupsForCapacityReservationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetGroupsForCapacityReservation">REST API Reference for GetGroupsForCapacityReservation Operation</seealso>
        public virtual GetGroupsForCapacityReservationResponse EndGetGroupsForCapacityReservation(IAsyncResult asyncResult)
        {
            return EndInvoke<GetGroupsForCapacityReservationResponse>(asyncResult);
        }

        #endregion
        
        #region  GetHostReservationPurchasePreview

        /// <summary>
        /// Preview a reservation purchase with configurations that match those of your Dedicated
        /// Host. You must have active Dedicated Hosts in your account before you purchase a reservation.
        /// 
        ///  
        /// <para>
        /// This is a preview of the <a>PurchaseHostReservation</a> action and does not result
        /// in the offering being purchased.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetHostReservationPurchasePreview service method.</param>
        /// 
        /// <returns>The response from the GetHostReservationPurchasePreview service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetHostReservationPurchasePreview">REST API Reference for GetHostReservationPurchasePreview Operation</seealso>
        public virtual GetHostReservationPurchasePreviewResponse GetHostReservationPurchasePreview(GetHostReservationPurchasePreviewRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetHostReservationPurchasePreviewRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetHostReservationPurchasePreviewResponseUnmarshaller.Instance;

            return Invoke<GetHostReservationPurchasePreviewResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetHostReservationPurchasePreview operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetHostReservationPurchasePreview operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetHostReservationPurchasePreview
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetHostReservationPurchasePreview">REST API Reference for GetHostReservationPurchasePreview Operation</seealso>
        public virtual IAsyncResult BeginGetHostReservationPurchasePreview(GetHostReservationPurchasePreviewRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetHostReservationPurchasePreviewRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetHostReservationPurchasePreviewResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetHostReservationPurchasePreview operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetHostReservationPurchasePreview.</param>
        /// 
        /// <returns>Returns a  GetHostReservationPurchasePreviewResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetHostReservationPurchasePreview">REST API Reference for GetHostReservationPurchasePreview Operation</seealso>
        public virtual GetHostReservationPurchasePreviewResponse EndGetHostReservationPurchasePreview(IAsyncResult asyncResult)
        {
            return EndInvoke<GetHostReservationPurchasePreviewResponse>(asyncResult);
        }

        #endregion
        
        #region  GetInstanceTypesFromInstanceRequirements

        /// <summary>
        /// Returns a list of instance types with the specified instance attributes. You can use
        /// the response to preview the instance types without launching instances. Note that
        /// the response does not consider capacity.
        /// 
        ///  
        /// <para>
        /// When you specify multiple parameters, you get instance types that satisfy all of the
        /// specified parameters. If you specify multiple values for a parameter, you get instance
        /// types that satisfy any of the specified values.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-attribute-based-instance-type-selection.html#spotfleet-get-instance-types-from-instance-requirements">Preview
        /// instance types with specified attributes</a>, <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-fleet-attribute-based-instance-type-selection.html">Attribute-based
        /// instance type selection for EC2 Fleet</a>, <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-attribute-based-instance-type-selection.html">Attribute-based
        /// instance type selection for Spot Fleet</a>, and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html">Spot
        /// placement score</a> in the <i>Amazon EC2 User Guide</i>, and <a href="https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-asg-instance-type-requirements.html">Creating
        /// an Auto Scaling group using attribute-based instance type selection</a> in the <i>Amazon
        /// EC2 Auto Scaling User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetInstanceTypesFromInstanceRequirements service method.</param>
        /// 
        /// <returns>The response from the GetInstanceTypesFromInstanceRequirements service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceTypesFromInstanceRequirements">REST API Reference for GetInstanceTypesFromInstanceRequirements Operation</seealso>
        public virtual GetInstanceTypesFromInstanceRequirementsResponse GetInstanceTypesFromInstanceRequirements(GetInstanceTypesFromInstanceRequirementsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetInstanceTypesFromInstanceRequirementsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetInstanceTypesFromInstanceRequirementsResponseUnmarshaller.Instance;

            return Invoke<GetInstanceTypesFromInstanceRequirementsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetInstanceTypesFromInstanceRequirements operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetInstanceTypesFromInstanceRequirements operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstanceTypesFromInstanceRequirements
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceTypesFromInstanceRequirements">REST API Reference for GetInstanceTypesFromInstanceRequirements Operation</seealso>
        public virtual IAsyncResult BeginGetInstanceTypesFromInstanceRequirements(GetInstanceTypesFromInstanceRequirementsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetInstanceTypesFromInstanceRequirementsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetInstanceTypesFromInstanceRequirementsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetInstanceTypesFromInstanceRequirements operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetInstanceTypesFromInstanceRequirements.</param>
        /// 
        /// <returns>Returns a  GetInstanceTypesFromInstanceRequirementsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceTypesFromInstanceRequirements">REST API Reference for GetInstanceTypesFromInstanceRequirements Operation</seealso>
        public virtual GetInstanceTypesFromInstanceRequirementsResponse EndGetInstanceTypesFromInstanceRequirements(IAsyncResult asyncResult)
        {
            return EndInvoke<GetInstanceTypesFromInstanceRequirementsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetInstanceUefiData

        /// <summary>
        /// A binary representation of the UEFI variable store. Only non-volatile variables are
        /// stored. This is a base64 encoded and zlib compressed binary value that must be properly
        /// encoded.
        /// 
        ///  
        /// <para>
        /// When you use <a href="https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html">register-image</a>
        /// to create an AMI, you can create an exact copy of your variable store by passing the
        /// UEFI data in the <code>UefiData</code> parameter. You can modify the UEFI data by
        /// using the <a href="https://github.com/awslabs/python-uefivars">python-uefivars tool</a>
        /// on GitHub. You can use the tool to convert the UEFI data into a human-readable format
        /// (JSON), which you can inspect and modify, and then convert back into the binary format
        /// to use with register-image.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/uefi-secure-boot.html">UEFI
        /// Secure Boot</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetInstanceUefiData service method.</param>
        /// 
        /// <returns>The response from the GetInstanceUefiData service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceUefiData">REST API Reference for GetInstanceUefiData Operation</seealso>
        public virtual GetInstanceUefiDataResponse GetInstanceUefiData(GetInstanceUefiDataRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetInstanceUefiDataRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetInstanceUefiDataResponseUnmarshaller.Instance;

            return Invoke<GetInstanceUefiDataResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetInstanceUefiData operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetInstanceUefiData operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetInstanceUefiData
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceUefiData">REST API Reference for GetInstanceUefiData Operation</seealso>
        public virtual IAsyncResult BeginGetInstanceUefiData(GetInstanceUefiDataRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetInstanceUefiDataRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetInstanceUefiDataResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetInstanceUefiData operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetInstanceUefiData.</param>
        /// 
        /// <returns>Returns a  GetInstanceUefiDataResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetInstanceUefiData">REST API Reference for GetInstanceUefiData Operation</seealso>
        public virtual GetInstanceUefiDataResponse EndGetInstanceUefiData(IAsyncResult asyncResult)
        {
            return EndInvoke<GetInstanceUefiDataResponse>(asyncResult);
        }

        #endregion
        
        #region  GetIpamAddressHistory

        /// <summary>
        /// Retrieve historical information about a CIDR within an IPAM scope. For more information,
        /// see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/view-history-cidr-ipam.html">View
        /// the history of IP addresses</a> in the <i>Amazon VPC IPAM User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetIpamAddressHistory service method.</param>
        /// 
        /// <returns>The response from the GetIpamAddressHistory service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamAddressHistory">REST API Reference for GetIpamAddressHistory Operation</seealso>
        public virtual GetIpamAddressHistoryResponse GetIpamAddressHistory(GetIpamAddressHistoryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamAddressHistoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamAddressHistoryResponseUnmarshaller.Instance;

            return Invoke<GetIpamAddressHistoryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetIpamAddressHistory operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetIpamAddressHistory operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetIpamAddressHistory
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamAddressHistory">REST API Reference for GetIpamAddressHistory Operation</seealso>
        public virtual IAsyncResult BeginGetIpamAddressHistory(GetIpamAddressHistoryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamAddressHistoryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamAddressHistoryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetIpamAddressHistory operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetIpamAddressHistory.</param>
        /// 
        /// <returns>Returns a  GetIpamAddressHistoryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamAddressHistory">REST API Reference for GetIpamAddressHistory Operation</seealso>
        public virtual GetIpamAddressHistoryResponse EndGetIpamAddressHistory(IAsyncResult asyncResult)
        {
            return EndInvoke<GetIpamAddressHistoryResponse>(asyncResult);
        }

        #endregion
        
        #region  GetIpamDiscoveredAccounts

        /// <summary>
        /// Gets IPAM discovered accounts. A discovered account is an Amazon Web Services account
        /// that is monitored under a resource discovery. If you have integrated IPAM with Amazon
        /// Web Services Organizations, all accounts in the organization are discovered accounts.
        /// Only the IPAM account can get all discovered accounts in the organization.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetIpamDiscoveredAccounts service method.</param>
        /// 
        /// <returns>The response from the GetIpamDiscoveredAccounts service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamDiscoveredAccounts">REST API Reference for GetIpamDiscoveredAccounts Operation</seealso>
        public virtual GetIpamDiscoveredAccountsResponse GetIpamDiscoveredAccounts(GetIpamDiscoveredAccountsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamDiscoveredAccountsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamDiscoveredAccountsResponseUnmarshaller.Instance;

            return Invoke<GetIpamDiscoveredAccountsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetIpamDiscoveredAccounts operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetIpamDiscoveredAccounts operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetIpamDiscoveredAccounts
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamDiscoveredAccounts">REST API Reference for GetIpamDiscoveredAccounts Operation</seealso>
        public virtual IAsyncResult BeginGetIpamDiscoveredAccounts(GetIpamDiscoveredAccountsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamDiscoveredAccountsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamDiscoveredAccountsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetIpamDiscoveredAccounts operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetIpamDiscoveredAccounts.</param>
        /// 
        /// <returns>Returns a  GetIpamDiscoveredAccountsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamDiscoveredAccounts">REST API Reference for GetIpamDiscoveredAccounts Operation</seealso>
        public virtual GetIpamDiscoveredAccountsResponse EndGetIpamDiscoveredAccounts(IAsyncResult asyncResult)
        {
            return EndInvoke<GetIpamDiscoveredAccountsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetIpamDiscoveredResourceCidrs

        /// <summary>
        /// Returns the resource CIDRs that are monitored as part of a resource discovery. A discovered
        /// resource is a resource CIDR monitored under a resource discovery. The following resources
        /// can be discovered: VPCs, Public IPv4 pools, VPC subnets, and Elastic IP addresses.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetIpamDiscoveredResourceCidrs service method.</param>
        /// 
        /// <returns>The response from the GetIpamDiscoveredResourceCidrs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamDiscoveredResourceCidrs">REST API Reference for GetIpamDiscoveredResourceCidrs Operation</seealso>
        public virtual GetIpamDiscoveredResourceCidrsResponse GetIpamDiscoveredResourceCidrs(GetIpamDiscoveredResourceCidrsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamDiscoveredResourceCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamDiscoveredResourceCidrsResponseUnmarshaller.Instance;

            return Invoke<GetIpamDiscoveredResourceCidrsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetIpamDiscoveredResourceCidrs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetIpamDiscoveredResourceCidrs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetIpamDiscoveredResourceCidrs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamDiscoveredResourceCidrs">REST API Reference for GetIpamDiscoveredResourceCidrs Operation</seealso>
        public virtual IAsyncResult BeginGetIpamDiscoveredResourceCidrs(GetIpamDiscoveredResourceCidrsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamDiscoveredResourceCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamDiscoveredResourceCidrsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetIpamDiscoveredResourceCidrs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetIpamDiscoveredResourceCidrs.</param>
        /// 
        /// <returns>Returns a  GetIpamDiscoveredResourceCidrsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamDiscoveredResourceCidrs">REST API Reference for GetIpamDiscoveredResourceCidrs Operation</seealso>
        public virtual GetIpamDiscoveredResourceCidrsResponse EndGetIpamDiscoveredResourceCidrs(IAsyncResult asyncResult)
        {
            return EndInvoke<GetIpamDiscoveredResourceCidrsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetIpamPoolAllocations

        /// <summary>
        /// Get a list of all the CIDR allocations in an IPAM pool. The Region you use should
        /// be the IPAM pool locale. The locale is the Amazon Web Services Region where this IPAM
        /// pool is available for allocations.
        /// 
        ///  <note> 
        /// <para>
        /// If you use this action after <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AllocateIpamPoolCidr.html">AllocateIpamPoolCidr</a>
        /// or <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ReleaseIpamPoolAllocation.html">ReleaseIpamPoolAllocation</a>,
        /// note that all EC2 API actions follow an <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/query-api-troubleshooting.html#eventual-consistency">eventual
        /// consistency</a> model.
        /// </para>
        ///  </note>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetIpamPoolAllocations service method.</param>
        /// 
        /// <returns>The response from the GetIpamPoolAllocations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPoolAllocations">REST API Reference for GetIpamPoolAllocations Operation</seealso>
        public virtual GetIpamPoolAllocationsResponse GetIpamPoolAllocations(GetIpamPoolAllocationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamPoolAllocationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamPoolAllocationsResponseUnmarshaller.Instance;

            return Invoke<GetIpamPoolAllocationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetIpamPoolAllocations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetIpamPoolAllocations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetIpamPoolAllocations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPoolAllocations">REST API Reference for GetIpamPoolAllocations Operation</seealso>
        public virtual IAsyncResult BeginGetIpamPoolAllocations(GetIpamPoolAllocationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamPoolAllocationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamPoolAllocationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetIpamPoolAllocations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetIpamPoolAllocations.</param>
        /// 
        /// <returns>Returns a  GetIpamPoolAllocationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPoolAllocations">REST API Reference for GetIpamPoolAllocations Operation</seealso>
        public virtual GetIpamPoolAllocationsResponse EndGetIpamPoolAllocations(IAsyncResult asyncResult)
        {
            return EndInvoke<GetIpamPoolAllocationsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetIpamPoolCidrs

        /// <summary>
        /// Get the CIDRs provisioned to an IPAM pool.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetIpamPoolCidrs service method.</param>
        /// 
        /// <returns>The response from the GetIpamPoolCidrs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPoolCidrs">REST API Reference for GetIpamPoolCidrs Operation</seealso>
        public virtual GetIpamPoolCidrsResponse GetIpamPoolCidrs(GetIpamPoolCidrsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamPoolCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamPoolCidrsResponseUnmarshaller.Instance;

            return Invoke<GetIpamPoolCidrsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetIpamPoolCidrs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetIpamPoolCidrs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetIpamPoolCidrs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPoolCidrs">REST API Reference for GetIpamPoolCidrs Operation</seealso>
        public virtual IAsyncResult BeginGetIpamPoolCidrs(GetIpamPoolCidrsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamPoolCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamPoolCidrsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetIpamPoolCidrs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetIpamPoolCidrs.</param>
        /// 
        /// <returns>Returns a  GetIpamPoolCidrsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamPoolCidrs">REST API Reference for GetIpamPoolCidrs Operation</seealso>
        public virtual GetIpamPoolCidrsResponse EndGetIpamPoolCidrs(IAsyncResult asyncResult)
        {
            return EndInvoke<GetIpamPoolCidrsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetIpamResourceCidrs

        /// <summary>
        /// Returns resource CIDRs managed by IPAM in a given scope. If an IPAM is associated
        /// with more than one resource discovery, the resource CIDRs across all of the resource
        /// discoveries is returned. A resource discovery is an IPAM component that enables IPAM
        /// to manage and monitor resources that belong to the owning account.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetIpamResourceCidrs service method.</param>
        /// 
        /// <returns>The response from the GetIpamResourceCidrs service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamResourceCidrs">REST API Reference for GetIpamResourceCidrs Operation</seealso>
        public virtual GetIpamResourceCidrsResponse GetIpamResourceCidrs(GetIpamResourceCidrsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamResourceCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamResourceCidrsResponseUnmarshaller.Instance;

            return Invoke<GetIpamResourceCidrsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetIpamResourceCidrs operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetIpamResourceCidrs operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetIpamResourceCidrs
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamResourceCidrs">REST API Reference for GetIpamResourceCidrs Operation</seealso>
        public virtual IAsyncResult BeginGetIpamResourceCidrs(GetIpamResourceCidrsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetIpamResourceCidrsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetIpamResourceCidrsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetIpamResourceCidrs operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetIpamResourceCidrs.</param>
        /// 
        /// <returns>Returns a  GetIpamResourceCidrsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetIpamResourceCidrs">REST API Reference for GetIpamResourceCidrs Operation</seealso>
        public virtual GetIpamResourceCidrsResponse EndGetIpamResourceCidrs(IAsyncResult asyncResult)
        {
            return EndInvoke<GetIpamResourceCidrsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetLaunchTemplateData

        /// <summary>
        /// Retrieves the configuration data of the specified instance. You can use this data
        /// to create a launch template. 
        /// 
        ///  
        /// <para>
        /// This action calls on other describe actions to get instance information. Depending
        /// on your instance configuration, you may need to allow the following actions in your
        /// IAM policy: <code>DescribeSpotInstanceRequests</code>, <code>DescribeInstanceCreditSpecifications</code>,
        /// <code>DescribeVolumes</code>, <code>DescribeInstanceAttribute</code>, and <code>DescribeElasticGpus</code>.
        /// Or, you can allow <code>describe*</code> depending on your instance requirements.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetLaunchTemplateData service method.</param>
        /// 
        /// <returns>The response from the GetLaunchTemplateData service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetLaunchTemplateData">REST API Reference for GetLaunchTemplateData Operation</seealso>
        public virtual GetLaunchTemplateDataResponse GetLaunchTemplateData(GetLaunchTemplateDataRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetLaunchTemplateDataRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetLaunchTemplateDataResponseUnmarshaller.Instance;

            return Invoke<GetLaunchTemplateDataResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetLaunchTemplateData operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetLaunchTemplateData operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetLaunchTemplateData
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetLaunchTemplateData">REST API Reference for GetLaunchTemplateData Operation</seealso>
        public virtual IAsyncResult BeginGetLaunchTemplateData(GetLaunchTemplateDataRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetLaunchTemplateDataRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetLaunchTemplateDataResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetLaunchTemplateData operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetLaunchTemplateData.</param>
        /// 
        /// <returns>Returns a  GetLaunchTemplateDataResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetLaunchTemplateData">REST API Reference for GetLaunchTemplateData Operation</seealso>
        public virtual GetLaunchTemplateDataResponse EndGetLaunchTemplateData(IAsyncResult asyncResult)
        {
            return EndInvoke<GetLaunchTemplateDataResponse>(asyncResult);
        }

        #endregion
        
        #region  GetManagedPrefixListAssociations

        /// <summary>
        /// Gets information about the resources that are associated with the specified managed
        /// prefix list.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetManagedPrefixListAssociations service method.</param>
        /// 
        /// <returns>The response from the GetManagedPrefixListAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetManagedPrefixListAssociations">REST API Reference for GetManagedPrefixListAssociations Operation</seealso>
        public virtual GetManagedPrefixListAssociationsResponse GetManagedPrefixListAssociations(GetManagedPrefixListAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetManagedPrefixListAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetManagedPrefixListAssociationsResponseUnmarshaller.Instance;

            return Invoke<GetManagedPrefixListAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetManagedPrefixListAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetManagedPrefixListAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetManagedPrefixListAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetManagedPrefixListAssociations">REST API Reference for GetManagedPrefixListAssociations Operation</seealso>
        public virtual IAsyncResult BeginGetManagedPrefixListAssociations(GetManagedPrefixListAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetManagedPrefixListAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetManagedPrefixListAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetManagedPrefixListAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetManagedPrefixListAssociations.</param>
        /// 
        /// <returns>Returns a  GetManagedPrefixListAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetManagedPrefixListAssociations">REST API Reference for GetManagedPrefixListAssociations Operation</seealso>
        public virtual GetManagedPrefixListAssociationsResponse EndGetManagedPrefixListAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<GetManagedPrefixListAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetManagedPrefixListEntries

        /// <summary>
        /// Gets information about the entries for a specified managed prefix list.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetManagedPrefixListEntries service method.</param>
        /// 
        /// <returns>The response from the GetManagedPrefixListEntries service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetManagedPrefixListEntries">REST API Reference for GetManagedPrefixListEntries Operation</seealso>
        public virtual GetManagedPrefixListEntriesResponse GetManagedPrefixListEntries(GetManagedPrefixListEntriesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetManagedPrefixListEntriesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetManagedPrefixListEntriesResponseUnmarshaller.Instance;

            return Invoke<GetManagedPrefixListEntriesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetManagedPrefixListEntries operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetManagedPrefixListEntries operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetManagedPrefixListEntries
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetManagedPrefixListEntries">REST API Reference for GetManagedPrefixListEntries Operation</seealso>
        public virtual IAsyncResult BeginGetManagedPrefixListEntries(GetManagedPrefixListEntriesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetManagedPrefixListEntriesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetManagedPrefixListEntriesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetManagedPrefixListEntries operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetManagedPrefixListEntries.</param>
        /// 
        /// <returns>Returns a  GetManagedPrefixListEntriesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetManagedPrefixListEntries">REST API Reference for GetManagedPrefixListEntries Operation</seealso>
        public virtual GetManagedPrefixListEntriesResponse EndGetManagedPrefixListEntries(IAsyncResult asyncResult)
        {
            return EndInvoke<GetManagedPrefixListEntriesResponse>(asyncResult);
        }

        #endregion
        
        #region  GetNetworkInsightsAccessScopeAnalysisFindings

        /// <summary>
        /// Gets the findings for the specified Network Access Scope analysis.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetNetworkInsightsAccessScopeAnalysisFindings service method.</param>
        /// 
        /// <returns>The response from the GetNetworkInsightsAccessScopeAnalysisFindings service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetNetworkInsightsAccessScopeAnalysisFindings">REST API Reference for GetNetworkInsightsAccessScopeAnalysisFindings Operation</seealso>
        public virtual GetNetworkInsightsAccessScopeAnalysisFindingsResponse GetNetworkInsightsAccessScopeAnalysisFindings(GetNetworkInsightsAccessScopeAnalysisFindingsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetNetworkInsightsAccessScopeAnalysisFindingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetNetworkInsightsAccessScopeAnalysisFindingsResponseUnmarshaller.Instance;

            return Invoke<GetNetworkInsightsAccessScopeAnalysisFindingsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetNetworkInsightsAccessScopeAnalysisFindings operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetNetworkInsightsAccessScopeAnalysisFindings operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetNetworkInsightsAccessScopeAnalysisFindings
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetNetworkInsightsAccessScopeAnalysisFindings">REST API Reference for GetNetworkInsightsAccessScopeAnalysisFindings Operation</seealso>
        public virtual IAsyncResult BeginGetNetworkInsightsAccessScopeAnalysisFindings(GetNetworkInsightsAccessScopeAnalysisFindingsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetNetworkInsightsAccessScopeAnalysisFindingsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetNetworkInsightsAccessScopeAnalysisFindingsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetNetworkInsightsAccessScopeAnalysisFindings operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetNetworkInsightsAccessScopeAnalysisFindings.</param>
        /// 
        /// <returns>Returns a  GetNetworkInsightsAccessScopeAnalysisFindingsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetNetworkInsightsAccessScopeAnalysisFindings">REST API Reference for GetNetworkInsightsAccessScopeAnalysisFindings Operation</seealso>
        public virtual GetNetworkInsightsAccessScopeAnalysisFindingsResponse EndGetNetworkInsightsAccessScopeAnalysisFindings(IAsyncResult asyncResult)
        {
            return EndInvoke<GetNetworkInsightsAccessScopeAnalysisFindingsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetNetworkInsightsAccessScopeContent

        /// <summary>
        /// Gets the content for the specified Network Access Scope.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetNetworkInsightsAccessScopeContent service method.</param>
        /// 
        /// <returns>The response from the GetNetworkInsightsAccessScopeContent service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetNetworkInsightsAccessScopeContent">REST API Reference for GetNetworkInsightsAccessScopeContent Operation</seealso>
        public virtual GetNetworkInsightsAccessScopeContentResponse GetNetworkInsightsAccessScopeContent(GetNetworkInsightsAccessScopeContentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetNetworkInsightsAccessScopeContentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetNetworkInsightsAccessScopeContentResponseUnmarshaller.Instance;

            return Invoke<GetNetworkInsightsAccessScopeContentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetNetworkInsightsAccessScopeContent operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetNetworkInsightsAccessScopeContent operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetNetworkInsightsAccessScopeContent
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetNetworkInsightsAccessScopeContent">REST API Reference for GetNetworkInsightsAccessScopeContent Operation</seealso>
        public virtual IAsyncResult BeginGetNetworkInsightsAccessScopeContent(GetNetworkInsightsAccessScopeContentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetNetworkInsightsAccessScopeContentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetNetworkInsightsAccessScopeContentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetNetworkInsightsAccessScopeContent operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetNetworkInsightsAccessScopeContent.</param>
        /// 
        /// <returns>Returns a  GetNetworkInsightsAccessScopeContentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetNetworkInsightsAccessScopeContent">REST API Reference for GetNetworkInsightsAccessScopeContent Operation</seealso>
        public virtual GetNetworkInsightsAccessScopeContentResponse EndGetNetworkInsightsAccessScopeContent(IAsyncResult asyncResult)
        {
            return EndInvoke<GetNetworkInsightsAccessScopeContentResponse>(asyncResult);
        }

        #endregion
        
        #region  GetPasswordData

        /// <summary>
        /// Retrieves the encrypted administrator password for a running Windows instance.
        /// 
        ///  
        /// <para>
        /// The Windows password is generated at boot by the <code>EC2Config</code> service or
        /// <code>EC2Launch</code> scripts (Windows Server 2016 and later). This usually only
        /// happens the first time an instance is launched. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/UsingConfig_WinAMI.html">EC2Config</a>
        /// and <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ec2launch.html">EC2Launch</a>
        /// in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// For the <code>EC2Config</code> service, the password is not generated for rebundled
        /// AMIs unless <code>Ec2SetPassword</code> is enabled before bundling.
        /// </para>
        ///  
        /// <para>
        /// The password is encrypted using the key pair that you specified when you launched
        /// the instance. You must provide the corresponding key pair file.
        /// </para>
        ///  
        /// <para>
        /// When you launch an instance, password generation and encryption may take a few minutes.
        /// If you try to retrieve the password before it's available, the output returns an empty
        /// string. We recommend that you wait up to 15 minutes after launching an instance before
        /// trying to retrieve the generated password.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetPasswordData service method.</param>
        /// 
        /// <returns>The response from the GetPasswordData service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetPasswordData">REST API Reference for GetPasswordData Operation</seealso>
        public virtual GetPasswordDataResponse GetPasswordData(GetPasswordDataRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetPasswordDataRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetPasswordDataResponseUnmarshaller.Instance;

            return Invoke<GetPasswordDataResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetPasswordData operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetPasswordData operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetPasswordData
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetPasswordData">REST API Reference for GetPasswordData Operation</seealso>
        public virtual IAsyncResult BeginGetPasswordData(GetPasswordDataRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetPasswordDataRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetPasswordDataResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetPasswordData operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetPasswordData.</param>
        /// 
        /// <returns>Returns a  GetPasswordDataResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetPasswordData">REST API Reference for GetPasswordData Operation</seealso>
        public virtual GetPasswordDataResponse EndGetPasswordData(IAsyncResult asyncResult)
        {
            return EndInvoke<GetPasswordDataResponse>(asyncResult);
        }

        #endregion
        
        #region  GetReservedInstancesExchangeQuote

        /// <summary>
        /// Returns a quote and exchange information for exchanging one or more specified Convertible
        /// Reserved Instances for a new Convertible Reserved Instance. If the exchange cannot
        /// be performed, the reason is returned in the response. Use <a>AcceptReservedInstancesExchangeQuote</a>
        /// to perform the exchange.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetReservedInstancesExchangeQuote service method.</param>
        /// 
        /// <returns>The response from the GetReservedInstancesExchangeQuote service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetReservedInstancesExchangeQuote">REST API Reference for GetReservedInstancesExchangeQuote Operation</seealso>
        public virtual GetReservedInstancesExchangeQuoteResponse GetReservedInstancesExchangeQuote(GetReservedInstancesExchangeQuoteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetReservedInstancesExchangeQuoteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetReservedInstancesExchangeQuoteResponseUnmarshaller.Instance;

            return Invoke<GetReservedInstancesExchangeQuoteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetReservedInstancesExchangeQuote operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetReservedInstancesExchangeQuote operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetReservedInstancesExchangeQuote
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetReservedInstancesExchangeQuote">REST API Reference for GetReservedInstancesExchangeQuote Operation</seealso>
        public virtual IAsyncResult BeginGetReservedInstancesExchangeQuote(GetReservedInstancesExchangeQuoteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetReservedInstancesExchangeQuoteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetReservedInstancesExchangeQuoteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetReservedInstancesExchangeQuote operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetReservedInstancesExchangeQuote.</param>
        /// 
        /// <returns>Returns a  GetReservedInstancesExchangeQuoteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetReservedInstancesExchangeQuote">REST API Reference for GetReservedInstancesExchangeQuote Operation</seealso>
        public virtual GetReservedInstancesExchangeQuoteResponse EndGetReservedInstancesExchangeQuote(IAsyncResult asyncResult)
        {
            return EndInvoke<GetReservedInstancesExchangeQuoteResponse>(asyncResult);
        }

        #endregion
        
        #region  GetSerialConsoleAccessStatus

        /// <summary>
        /// Retrieves the access status of your account to the EC2 serial console of all instances.
        /// By default, access to the EC2 serial console is disabled for your account. For more
        /// information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configure-access-to-serial-console.html#serial-console-account-access">Manage
        /// account access to the EC2 serial console</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetSerialConsoleAccessStatus service method.</param>
        /// 
        /// <returns>The response from the GetSerialConsoleAccessStatus service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSerialConsoleAccessStatus">REST API Reference for GetSerialConsoleAccessStatus Operation</seealso>
        public virtual GetSerialConsoleAccessStatusResponse GetSerialConsoleAccessStatus(GetSerialConsoleAccessStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetSerialConsoleAccessStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetSerialConsoleAccessStatusResponseUnmarshaller.Instance;

            return Invoke<GetSerialConsoleAccessStatusResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetSerialConsoleAccessStatus operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetSerialConsoleAccessStatus operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSerialConsoleAccessStatus
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSerialConsoleAccessStatus">REST API Reference for GetSerialConsoleAccessStatus Operation</seealso>
        public virtual IAsyncResult BeginGetSerialConsoleAccessStatus(GetSerialConsoleAccessStatusRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetSerialConsoleAccessStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetSerialConsoleAccessStatusResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetSerialConsoleAccessStatus operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetSerialConsoleAccessStatus.</param>
        /// 
        /// <returns>Returns a  GetSerialConsoleAccessStatusResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSerialConsoleAccessStatus">REST API Reference for GetSerialConsoleAccessStatus Operation</seealso>
        public virtual GetSerialConsoleAccessStatusResponse EndGetSerialConsoleAccessStatus(IAsyncResult asyncResult)
        {
            return EndInvoke<GetSerialConsoleAccessStatusResponse>(asyncResult);
        }

        #endregion
        
        #region  GetSpotPlacementScores

        /// <summary>
        /// Calculates the Spot placement score for a Region or Availability Zone based on the
        /// specified target capacity and compute requirements.
        /// 
        ///  
        /// <para>
        /// You can specify your compute requirements either by using <code>InstanceRequirementsWithMetadata</code>
        /// and letting Amazon EC2 choose the optimal instance types to fulfill your Spot request,
        /// or you can specify the instance types by using <code>InstanceTypes</code>.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-placement-score.html">Spot
        /// placement score</a> in the Amazon EC2 User Guide.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetSpotPlacementScores service method.</param>
        /// 
        /// <returns>The response from the GetSpotPlacementScores service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSpotPlacementScores">REST API Reference for GetSpotPlacementScores Operation</seealso>
        public virtual GetSpotPlacementScoresResponse GetSpotPlacementScores(GetSpotPlacementScoresRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetSpotPlacementScoresRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetSpotPlacementScoresResponseUnmarshaller.Instance;

            return Invoke<GetSpotPlacementScoresResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetSpotPlacementScores operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetSpotPlacementScores operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSpotPlacementScores
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSpotPlacementScores">REST API Reference for GetSpotPlacementScores Operation</seealso>
        public virtual IAsyncResult BeginGetSpotPlacementScores(GetSpotPlacementScoresRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetSpotPlacementScoresRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetSpotPlacementScoresResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetSpotPlacementScores operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetSpotPlacementScores.</param>
        /// 
        /// <returns>Returns a  GetSpotPlacementScoresResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSpotPlacementScores">REST API Reference for GetSpotPlacementScores Operation</seealso>
        public virtual GetSpotPlacementScoresResponse EndGetSpotPlacementScores(IAsyncResult asyncResult)
        {
            return EndInvoke<GetSpotPlacementScoresResponse>(asyncResult);
        }

        #endregion
        
        #region  GetSubnetCidrReservations

        /// <summary>
        /// Gets information about the subnet CIDR reservations.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetSubnetCidrReservations service method.</param>
        /// 
        /// <returns>The response from the GetSubnetCidrReservations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSubnetCidrReservations">REST API Reference for GetSubnetCidrReservations Operation</seealso>
        public virtual GetSubnetCidrReservationsResponse GetSubnetCidrReservations(GetSubnetCidrReservationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetSubnetCidrReservationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetSubnetCidrReservationsResponseUnmarshaller.Instance;

            return Invoke<GetSubnetCidrReservationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetSubnetCidrReservations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetSubnetCidrReservations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSubnetCidrReservations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSubnetCidrReservations">REST API Reference for GetSubnetCidrReservations Operation</seealso>
        public virtual IAsyncResult BeginGetSubnetCidrReservations(GetSubnetCidrReservationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetSubnetCidrReservationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetSubnetCidrReservationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetSubnetCidrReservations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetSubnetCidrReservations.</param>
        /// 
        /// <returns>Returns a  GetSubnetCidrReservationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetSubnetCidrReservations">REST API Reference for GetSubnetCidrReservations Operation</seealso>
        public virtual GetSubnetCidrReservationsResponse EndGetSubnetCidrReservations(IAsyncResult asyncResult)
        {
            return EndInvoke<GetSubnetCidrReservationsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetTransitGatewayAttachmentPropagations

        /// <summary>
        /// Lists the route tables to which the specified resource attachment propagates routes.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayAttachmentPropagations service method.</param>
        /// 
        /// <returns>The response from the GetTransitGatewayAttachmentPropagations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayAttachmentPropagations">REST API Reference for GetTransitGatewayAttachmentPropagations Operation</seealso>
        public virtual GetTransitGatewayAttachmentPropagationsResponse GetTransitGatewayAttachmentPropagations(GetTransitGatewayAttachmentPropagationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayAttachmentPropagationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayAttachmentPropagationsResponseUnmarshaller.Instance;

            return Invoke<GetTransitGatewayAttachmentPropagationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetTransitGatewayAttachmentPropagations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayAttachmentPropagations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTransitGatewayAttachmentPropagations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayAttachmentPropagations">REST API Reference for GetTransitGatewayAttachmentPropagations Operation</seealso>
        public virtual IAsyncResult BeginGetTransitGatewayAttachmentPropagations(GetTransitGatewayAttachmentPropagationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayAttachmentPropagationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayAttachmentPropagationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetTransitGatewayAttachmentPropagations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTransitGatewayAttachmentPropagations.</param>
        /// 
        /// <returns>Returns a  GetTransitGatewayAttachmentPropagationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayAttachmentPropagations">REST API Reference for GetTransitGatewayAttachmentPropagations Operation</seealso>
        public virtual GetTransitGatewayAttachmentPropagationsResponse EndGetTransitGatewayAttachmentPropagations(IAsyncResult asyncResult)
        {
            return EndInvoke<GetTransitGatewayAttachmentPropagationsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetTransitGatewayMulticastDomainAssociations

        /// <summary>
        /// Gets information about the associations for the transit gateway multicast domain.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayMulticastDomainAssociations service method.</param>
        /// 
        /// <returns>The response from the GetTransitGatewayMulticastDomainAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayMulticastDomainAssociations">REST API Reference for GetTransitGatewayMulticastDomainAssociations Operation</seealso>
        public virtual GetTransitGatewayMulticastDomainAssociationsResponse GetTransitGatewayMulticastDomainAssociations(GetTransitGatewayMulticastDomainAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance;

            return Invoke<GetTransitGatewayMulticastDomainAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetTransitGatewayMulticastDomainAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayMulticastDomainAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTransitGatewayMulticastDomainAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayMulticastDomainAssociations">REST API Reference for GetTransitGatewayMulticastDomainAssociations Operation</seealso>
        public virtual IAsyncResult BeginGetTransitGatewayMulticastDomainAssociations(GetTransitGatewayMulticastDomainAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetTransitGatewayMulticastDomainAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTransitGatewayMulticastDomainAssociations.</param>
        /// 
        /// <returns>Returns a  GetTransitGatewayMulticastDomainAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayMulticastDomainAssociations">REST API Reference for GetTransitGatewayMulticastDomainAssociations Operation</seealso>
        public virtual GetTransitGatewayMulticastDomainAssociationsResponse EndGetTransitGatewayMulticastDomainAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<GetTransitGatewayMulticastDomainAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetTransitGatewayPolicyTableAssociations

        /// <summary>
        /// Gets a list of the transit gateway policy table associations.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayPolicyTableAssociations service method.</param>
        /// 
        /// <returns>The response from the GetTransitGatewayPolicyTableAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPolicyTableAssociations">REST API Reference for GetTransitGatewayPolicyTableAssociations Operation</seealso>
        public virtual GetTransitGatewayPolicyTableAssociationsResponse GetTransitGatewayPolicyTableAssociations(GetTransitGatewayPolicyTableAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayPolicyTableAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayPolicyTableAssociationsResponseUnmarshaller.Instance;

            return Invoke<GetTransitGatewayPolicyTableAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetTransitGatewayPolicyTableAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayPolicyTableAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTransitGatewayPolicyTableAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPolicyTableAssociations">REST API Reference for GetTransitGatewayPolicyTableAssociations Operation</seealso>
        public virtual IAsyncResult BeginGetTransitGatewayPolicyTableAssociations(GetTransitGatewayPolicyTableAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayPolicyTableAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayPolicyTableAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetTransitGatewayPolicyTableAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTransitGatewayPolicyTableAssociations.</param>
        /// 
        /// <returns>Returns a  GetTransitGatewayPolicyTableAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPolicyTableAssociations">REST API Reference for GetTransitGatewayPolicyTableAssociations Operation</seealso>
        public virtual GetTransitGatewayPolicyTableAssociationsResponse EndGetTransitGatewayPolicyTableAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<GetTransitGatewayPolicyTableAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetTransitGatewayPolicyTableEntries

        /// <summary>
        /// Returns a list of transit gateway policy table entries.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayPolicyTableEntries service method.</param>
        /// 
        /// <returns>The response from the GetTransitGatewayPolicyTableEntries service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPolicyTableEntries">REST API Reference for GetTransitGatewayPolicyTableEntries Operation</seealso>
        public virtual GetTransitGatewayPolicyTableEntriesResponse GetTransitGatewayPolicyTableEntries(GetTransitGatewayPolicyTableEntriesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayPolicyTableEntriesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayPolicyTableEntriesResponseUnmarshaller.Instance;

            return Invoke<GetTransitGatewayPolicyTableEntriesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetTransitGatewayPolicyTableEntries operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayPolicyTableEntries operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTransitGatewayPolicyTableEntries
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPolicyTableEntries">REST API Reference for GetTransitGatewayPolicyTableEntries Operation</seealso>
        public virtual IAsyncResult BeginGetTransitGatewayPolicyTableEntries(GetTransitGatewayPolicyTableEntriesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayPolicyTableEntriesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayPolicyTableEntriesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetTransitGatewayPolicyTableEntries operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTransitGatewayPolicyTableEntries.</param>
        /// 
        /// <returns>Returns a  GetTransitGatewayPolicyTableEntriesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPolicyTableEntries">REST API Reference for GetTransitGatewayPolicyTableEntries Operation</seealso>
        public virtual GetTransitGatewayPolicyTableEntriesResponse EndGetTransitGatewayPolicyTableEntries(IAsyncResult asyncResult)
        {
            return EndInvoke<GetTransitGatewayPolicyTableEntriesResponse>(asyncResult);
        }

        #endregion
        
        #region  GetTransitGatewayPrefixListReferences

        /// <summary>
        /// Gets information about the prefix list references in a specified transit gateway route
        /// table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayPrefixListReferences service method.</param>
        /// 
        /// <returns>The response from the GetTransitGatewayPrefixListReferences service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPrefixListReferences">REST API Reference for GetTransitGatewayPrefixListReferences Operation</seealso>
        public virtual GetTransitGatewayPrefixListReferencesResponse GetTransitGatewayPrefixListReferences(GetTransitGatewayPrefixListReferencesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayPrefixListReferencesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayPrefixListReferencesResponseUnmarshaller.Instance;

            return Invoke<GetTransitGatewayPrefixListReferencesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetTransitGatewayPrefixListReferences operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayPrefixListReferences operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTransitGatewayPrefixListReferences
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPrefixListReferences">REST API Reference for GetTransitGatewayPrefixListReferences Operation</seealso>
        public virtual IAsyncResult BeginGetTransitGatewayPrefixListReferences(GetTransitGatewayPrefixListReferencesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayPrefixListReferencesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayPrefixListReferencesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetTransitGatewayPrefixListReferences operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTransitGatewayPrefixListReferences.</param>
        /// 
        /// <returns>Returns a  GetTransitGatewayPrefixListReferencesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayPrefixListReferences">REST API Reference for GetTransitGatewayPrefixListReferences Operation</seealso>
        public virtual GetTransitGatewayPrefixListReferencesResponse EndGetTransitGatewayPrefixListReferences(IAsyncResult asyncResult)
        {
            return EndInvoke<GetTransitGatewayPrefixListReferencesResponse>(asyncResult);
        }

        #endregion
        
        #region  GetTransitGatewayRouteTableAssociations

        /// <summary>
        /// Gets information about the associations for the specified transit gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayRouteTableAssociations service method.</param>
        /// 
        /// <returns>The response from the GetTransitGatewayRouteTableAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayRouteTableAssociations">REST API Reference for GetTransitGatewayRouteTableAssociations Operation</seealso>
        public virtual GetTransitGatewayRouteTableAssociationsResponse GetTransitGatewayRouteTableAssociations(GetTransitGatewayRouteTableAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayRouteTableAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayRouteTableAssociationsResponseUnmarshaller.Instance;

            return Invoke<GetTransitGatewayRouteTableAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetTransitGatewayRouteTableAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayRouteTableAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTransitGatewayRouteTableAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayRouteTableAssociations">REST API Reference for GetTransitGatewayRouteTableAssociations Operation</seealso>
        public virtual IAsyncResult BeginGetTransitGatewayRouteTableAssociations(GetTransitGatewayRouteTableAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayRouteTableAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayRouteTableAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetTransitGatewayRouteTableAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTransitGatewayRouteTableAssociations.</param>
        /// 
        /// <returns>Returns a  GetTransitGatewayRouteTableAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayRouteTableAssociations">REST API Reference for GetTransitGatewayRouteTableAssociations Operation</seealso>
        public virtual GetTransitGatewayRouteTableAssociationsResponse EndGetTransitGatewayRouteTableAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<GetTransitGatewayRouteTableAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetTransitGatewayRouteTablePropagations

        /// <summary>
        /// Gets information about the route table propagations for the specified transit gateway
        /// route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayRouteTablePropagations service method.</param>
        /// 
        /// <returns>The response from the GetTransitGatewayRouteTablePropagations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayRouteTablePropagations">REST API Reference for GetTransitGatewayRouteTablePropagations Operation</seealso>
        public virtual GetTransitGatewayRouteTablePropagationsResponse GetTransitGatewayRouteTablePropagations(GetTransitGatewayRouteTablePropagationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayRouteTablePropagationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayRouteTablePropagationsResponseUnmarshaller.Instance;

            return Invoke<GetTransitGatewayRouteTablePropagationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetTransitGatewayRouteTablePropagations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetTransitGatewayRouteTablePropagations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetTransitGatewayRouteTablePropagations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayRouteTablePropagations">REST API Reference for GetTransitGatewayRouteTablePropagations Operation</seealso>
        public virtual IAsyncResult BeginGetTransitGatewayRouteTablePropagations(GetTransitGatewayRouteTablePropagationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetTransitGatewayRouteTablePropagationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetTransitGatewayRouteTablePropagationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetTransitGatewayRouteTablePropagations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetTransitGatewayRouteTablePropagations.</param>
        /// 
        /// <returns>Returns a  GetTransitGatewayRouteTablePropagationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetTransitGatewayRouteTablePropagations">REST API Reference for GetTransitGatewayRouteTablePropagations Operation</seealso>
        public virtual GetTransitGatewayRouteTablePropagationsResponse EndGetTransitGatewayRouteTablePropagations(IAsyncResult asyncResult)
        {
            return EndInvoke<GetTransitGatewayRouteTablePropagationsResponse>(asyncResult);
        }

        #endregion
        
        #region  GetVerifiedAccessEndpointPolicy

        /// <summary>
        /// Get the Verified Access policy associated with the endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetVerifiedAccessEndpointPolicy service method.</param>
        /// 
        /// <returns>The response from the GetVerifiedAccessEndpointPolicy service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVerifiedAccessEndpointPolicy">REST API Reference for GetVerifiedAccessEndpointPolicy Operation</seealso>
        public virtual GetVerifiedAccessEndpointPolicyResponse GetVerifiedAccessEndpointPolicy(GetVerifiedAccessEndpointPolicyRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVerifiedAccessEndpointPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVerifiedAccessEndpointPolicyResponseUnmarshaller.Instance;

            return Invoke<GetVerifiedAccessEndpointPolicyResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetVerifiedAccessEndpointPolicy operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetVerifiedAccessEndpointPolicy operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetVerifiedAccessEndpointPolicy
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVerifiedAccessEndpointPolicy">REST API Reference for GetVerifiedAccessEndpointPolicy Operation</seealso>
        public virtual IAsyncResult BeginGetVerifiedAccessEndpointPolicy(GetVerifiedAccessEndpointPolicyRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVerifiedAccessEndpointPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVerifiedAccessEndpointPolicyResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetVerifiedAccessEndpointPolicy operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetVerifiedAccessEndpointPolicy.</param>
        /// 
        /// <returns>Returns a  GetVerifiedAccessEndpointPolicyResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVerifiedAccessEndpointPolicy">REST API Reference for GetVerifiedAccessEndpointPolicy Operation</seealso>
        public virtual GetVerifiedAccessEndpointPolicyResponse EndGetVerifiedAccessEndpointPolicy(IAsyncResult asyncResult)
        {
            return EndInvoke<GetVerifiedAccessEndpointPolicyResponse>(asyncResult);
        }

        #endregion
        
        #region  GetVerifiedAccessGroupPolicy

        /// <summary>
        /// Shows the contents of the Verified Access policy associated with the group.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetVerifiedAccessGroupPolicy service method.</param>
        /// 
        /// <returns>The response from the GetVerifiedAccessGroupPolicy service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVerifiedAccessGroupPolicy">REST API Reference for GetVerifiedAccessGroupPolicy Operation</seealso>
        public virtual GetVerifiedAccessGroupPolicyResponse GetVerifiedAccessGroupPolicy(GetVerifiedAccessGroupPolicyRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVerifiedAccessGroupPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVerifiedAccessGroupPolicyResponseUnmarshaller.Instance;

            return Invoke<GetVerifiedAccessGroupPolicyResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetVerifiedAccessGroupPolicy operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetVerifiedAccessGroupPolicy operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetVerifiedAccessGroupPolicy
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVerifiedAccessGroupPolicy">REST API Reference for GetVerifiedAccessGroupPolicy Operation</seealso>
        public virtual IAsyncResult BeginGetVerifiedAccessGroupPolicy(GetVerifiedAccessGroupPolicyRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVerifiedAccessGroupPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVerifiedAccessGroupPolicyResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetVerifiedAccessGroupPolicy operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetVerifiedAccessGroupPolicy.</param>
        /// 
        /// <returns>Returns a  GetVerifiedAccessGroupPolicyResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVerifiedAccessGroupPolicy">REST API Reference for GetVerifiedAccessGroupPolicy Operation</seealso>
        public virtual GetVerifiedAccessGroupPolicyResponse EndGetVerifiedAccessGroupPolicy(IAsyncResult asyncResult)
        {
            return EndInvoke<GetVerifiedAccessGroupPolicyResponse>(asyncResult);
        }

        #endregion
        
        #region  GetVpnConnectionDeviceSampleConfiguration

        /// <summary>
        /// Download an Amazon Web Services-provided sample configuration file to be used with
        /// the customer gateway device specified for your Site-to-Site VPN connection.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetVpnConnectionDeviceSampleConfiguration service method.</param>
        /// 
        /// <returns>The response from the GetVpnConnectionDeviceSampleConfiguration service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnConnectionDeviceSampleConfiguration">REST API Reference for GetVpnConnectionDeviceSampleConfiguration Operation</seealso>
        public virtual GetVpnConnectionDeviceSampleConfigurationResponse GetVpnConnectionDeviceSampleConfiguration(GetVpnConnectionDeviceSampleConfigurationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVpnConnectionDeviceSampleConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVpnConnectionDeviceSampleConfigurationResponseUnmarshaller.Instance;

            return Invoke<GetVpnConnectionDeviceSampleConfigurationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetVpnConnectionDeviceSampleConfiguration operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetVpnConnectionDeviceSampleConfiguration operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetVpnConnectionDeviceSampleConfiguration
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnConnectionDeviceSampleConfiguration">REST API Reference for GetVpnConnectionDeviceSampleConfiguration Operation</seealso>
        public virtual IAsyncResult BeginGetVpnConnectionDeviceSampleConfiguration(GetVpnConnectionDeviceSampleConfigurationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVpnConnectionDeviceSampleConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVpnConnectionDeviceSampleConfigurationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetVpnConnectionDeviceSampleConfiguration operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetVpnConnectionDeviceSampleConfiguration.</param>
        /// 
        /// <returns>Returns a  GetVpnConnectionDeviceSampleConfigurationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnConnectionDeviceSampleConfiguration">REST API Reference for GetVpnConnectionDeviceSampleConfiguration Operation</seealso>
        public virtual GetVpnConnectionDeviceSampleConfigurationResponse EndGetVpnConnectionDeviceSampleConfiguration(IAsyncResult asyncResult)
        {
            return EndInvoke<GetVpnConnectionDeviceSampleConfigurationResponse>(asyncResult);
        }

        #endregion
        
        #region  GetVpnConnectionDeviceTypes

        /// <summary>
        /// Obtain a list of customer gateway devices for which sample configuration files can
        /// be provided. The request has no additional parameters. You can also see the list of
        /// device types with sample configuration files available under <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/your-cgw.html">Your
        /// customer gateway device</a> in the <i>Amazon Web Services Site-to-Site VPN User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetVpnConnectionDeviceTypes service method.</param>
        /// 
        /// <returns>The response from the GetVpnConnectionDeviceTypes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnConnectionDeviceTypes">REST API Reference for GetVpnConnectionDeviceTypes Operation</seealso>
        public virtual GetVpnConnectionDeviceTypesResponse GetVpnConnectionDeviceTypes(GetVpnConnectionDeviceTypesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVpnConnectionDeviceTypesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVpnConnectionDeviceTypesResponseUnmarshaller.Instance;

            return Invoke<GetVpnConnectionDeviceTypesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetVpnConnectionDeviceTypes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetVpnConnectionDeviceTypes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetVpnConnectionDeviceTypes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnConnectionDeviceTypes">REST API Reference for GetVpnConnectionDeviceTypes Operation</seealso>
        public virtual IAsyncResult BeginGetVpnConnectionDeviceTypes(GetVpnConnectionDeviceTypesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVpnConnectionDeviceTypesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVpnConnectionDeviceTypesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetVpnConnectionDeviceTypes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetVpnConnectionDeviceTypes.</param>
        /// 
        /// <returns>Returns a  GetVpnConnectionDeviceTypesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnConnectionDeviceTypes">REST API Reference for GetVpnConnectionDeviceTypes Operation</seealso>
        public virtual GetVpnConnectionDeviceTypesResponse EndGetVpnConnectionDeviceTypes(IAsyncResult asyncResult)
        {
            return EndInvoke<GetVpnConnectionDeviceTypesResponse>(asyncResult);
        }

        #endregion
        
        #region  GetVpnTunnelReplacementStatus

        /// <summary>
        /// Get details of available tunnel endpoint maintenance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the GetVpnTunnelReplacementStatus service method.</param>
        /// 
        /// <returns>The response from the GetVpnTunnelReplacementStatus service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnTunnelReplacementStatus">REST API Reference for GetVpnTunnelReplacementStatus Operation</seealso>
        public virtual GetVpnTunnelReplacementStatusResponse GetVpnTunnelReplacementStatus(GetVpnTunnelReplacementStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVpnTunnelReplacementStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVpnTunnelReplacementStatusResponseUnmarshaller.Instance;

            return Invoke<GetVpnTunnelReplacementStatusResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the GetVpnTunnelReplacementStatus operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the GetVpnTunnelReplacementStatus operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetVpnTunnelReplacementStatus
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnTunnelReplacementStatus">REST API Reference for GetVpnTunnelReplacementStatus Operation</seealso>
        public virtual IAsyncResult BeginGetVpnTunnelReplacementStatus(GetVpnTunnelReplacementStatusRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = GetVpnTunnelReplacementStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = GetVpnTunnelReplacementStatusResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  GetVpnTunnelReplacementStatus operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginGetVpnTunnelReplacementStatus.</param>
        /// 
        /// <returns>Returns a  GetVpnTunnelReplacementStatusResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/GetVpnTunnelReplacementStatus">REST API Reference for GetVpnTunnelReplacementStatus Operation</seealso>
        public virtual GetVpnTunnelReplacementStatusResponse EndGetVpnTunnelReplacementStatus(IAsyncResult asyncResult)
        {
            return EndInvoke<GetVpnTunnelReplacementStatusResponse>(asyncResult);
        }

        #endregion
        
        #region  ImportClientVpnClientCertificateRevocationList

        /// <summary>
        /// Uploads a client certificate revocation list to the specified Client VPN endpoint.
        /// Uploading a client certificate revocation list overwrites the existing client certificate
        /// revocation list.
        /// 
        ///  
        /// <para>
        /// Uploading a client certificate revocation list resets existing client connections.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ImportClientVpnClientCertificateRevocationList service method.</param>
        /// 
        /// <returns>The response from the ImportClientVpnClientCertificateRevocationList service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportClientVpnClientCertificateRevocationList">REST API Reference for ImportClientVpnClientCertificateRevocationList Operation</seealso>
        public virtual ImportClientVpnClientCertificateRevocationListResponse ImportClientVpnClientCertificateRevocationList(ImportClientVpnClientCertificateRevocationListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportClientVpnClientCertificateRevocationListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportClientVpnClientCertificateRevocationListResponseUnmarshaller.Instance;

            return Invoke<ImportClientVpnClientCertificateRevocationListResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ImportClientVpnClientCertificateRevocationList operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ImportClientVpnClientCertificateRevocationList operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndImportClientVpnClientCertificateRevocationList
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportClientVpnClientCertificateRevocationList">REST API Reference for ImportClientVpnClientCertificateRevocationList Operation</seealso>
        public virtual IAsyncResult BeginImportClientVpnClientCertificateRevocationList(ImportClientVpnClientCertificateRevocationListRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportClientVpnClientCertificateRevocationListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportClientVpnClientCertificateRevocationListResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ImportClientVpnClientCertificateRevocationList operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginImportClientVpnClientCertificateRevocationList.</param>
        /// 
        /// <returns>Returns a  ImportClientVpnClientCertificateRevocationListResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportClientVpnClientCertificateRevocationList">REST API Reference for ImportClientVpnClientCertificateRevocationList Operation</seealso>
        public virtual ImportClientVpnClientCertificateRevocationListResponse EndImportClientVpnClientCertificateRevocationList(IAsyncResult asyncResult)
        {
            return EndInvoke<ImportClientVpnClientCertificateRevocationListResponse>(asyncResult);
        }

        #endregion
        
        #region  ImportImage

        /// <summary>
        /// <note> 
        /// <para>
        /// To import your virtual machines (VMs) with a console-based experience, you can use
        /// the <i>Import virtual machine images to Amazon Web Services</i> template in the <a
        /// href="https://console.aws.amazon.com/migrationhub/orchestrator">Migration Hub Orchestrator
        /// console</a>. For more information, see the <a href="https://docs.aws.amazon.com/migrationhub-orchestrator/latest/userguide/import-vm-images.html">
        /// <i>Migration Hub Orchestrator User Guide</i> </a>.
        /// </para>
        ///  </note> 
        /// <para>
        /// Import single or multi-volume disk images or EBS snapshots into an Amazon Machine
        /// Image (AMI).
        /// </para>
        ///  <important> 
        /// <para>
        /// Amazon Web Services VM Import/Export strongly recommends specifying a value for either
        /// the <code>--license-type</code> or <code>--usage-operation</code> parameter when you
        /// create a new VM Import task. This ensures your operating system is licensed appropriately
        /// and your billing is optimized.
        /// </para>
        ///  </important> 
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-image-import.html">Importing
        /// a VM as an image using VM Import/Export</a> in the <i>VM Import/Export User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ImportImage service method.</param>
        /// 
        /// <returns>The response from the ImportImage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportImage">REST API Reference for ImportImage Operation</seealso>
        public virtual ImportImageResponse ImportImage(ImportImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportImageResponseUnmarshaller.Instance;

            return Invoke<ImportImageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ImportImage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ImportImage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndImportImage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportImage">REST API Reference for ImportImage Operation</seealso>
        public virtual IAsyncResult BeginImportImage(ImportImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportImageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ImportImage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginImportImage.</param>
        /// 
        /// <returns>Returns a  ImportImageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportImage">REST API Reference for ImportImage Operation</seealso>
        public virtual ImportImageResponse EndImportImage(IAsyncResult asyncResult)
        {
            return EndInvoke<ImportImageResponse>(asyncResult);
        }

        #endregion
        
        #region  ImportInstance

        /// <summary>
        /// <note> 
        /// <para>
        /// We recommend that you use the <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ImportImage.html">
        /// <code>ImportImage</code> </a> API. For more information, see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-image-import.html">Importing
        /// a VM as an image using VM Import/Export</a> in the <i>VM Import/Export User Guide</i>.
        /// </para>
        ///  </note> 
        /// <para>
        /// Creates an import instance task using metadata from the specified disk image.
        /// </para>
        ///  
        /// <para>
        /// This API action is not supported by the Command Line Interface (CLI). For information
        /// about using the Amazon EC2 CLI, which is deprecated, see <a href="https://awsdocs.s3.amazonaws.com/EC2/ec2-clt.pdf#UsingVirtualMachinesinAmazonEC2">Importing
        /// a VM to Amazon EC2</a> in the <i>Amazon EC2 CLI Reference</i> PDF file.
        /// </para>
        ///  
        /// <para>
        /// This API action supports only single-volume VMs. To import multi-volume VMs, use <a>ImportImage</a>
        /// instead.
        /// </para>
        ///  
        /// <para>
        /// For information about the import manifest referenced by this API action, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM
        /// Import Manifest</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ImportInstance service method.</param>
        /// 
        /// <returns>The response from the ImportInstance service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportInstance">REST API Reference for ImportInstance Operation</seealso>
        public virtual ImportInstanceResponse ImportInstance(ImportInstanceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportInstanceResponseUnmarshaller.Instance;

            return Invoke<ImportInstanceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ImportInstance operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ImportInstance operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndImportInstance
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportInstance">REST API Reference for ImportInstance Operation</seealso>
        public virtual IAsyncResult BeginImportInstance(ImportInstanceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportInstanceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ImportInstance operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginImportInstance.</param>
        /// 
        /// <returns>Returns a  ImportInstanceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportInstance">REST API Reference for ImportInstance Operation</seealso>
        public virtual ImportInstanceResponse EndImportInstance(IAsyncResult asyncResult)
        {
            return EndInvoke<ImportInstanceResponse>(asyncResult);
        }

        #endregion
        
        #region  ImportKeyPair

        /// <summary>
        /// Imports the public key from an RSA or ED25519 key pair that you created with a third-party
        /// tool. Compare this with <a>CreateKeyPair</a>, in which Amazon Web Services creates
        /// the key pair and gives the keys to you (Amazon Web Services keeps a copy of the public
        /// key). With ImportKeyPair, you create the key pair and give Amazon Web Services just
        /// the public key. The private key is never transferred between you and Amazon Web Services.
        /// 
        ///  
        /// <para>
        /// For more information about key pairs, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Amazon
        /// EC2 key pairs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ImportKeyPair service method.</param>
        /// 
        /// <returns>The response from the ImportKeyPair service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportKeyPair">REST API Reference for ImportKeyPair Operation</seealso>
        public virtual ImportKeyPairResponse ImportKeyPair(ImportKeyPairRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportKeyPairRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportKeyPairResponseUnmarshaller.Instance;

            return Invoke<ImportKeyPairResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ImportKeyPair operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ImportKeyPair operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndImportKeyPair
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportKeyPair">REST API Reference for ImportKeyPair Operation</seealso>
        public virtual IAsyncResult BeginImportKeyPair(ImportKeyPairRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportKeyPairRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportKeyPairResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ImportKeyPair operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginImportKeyPair.</param>
        /// 
        /// <returns>Returns a  ImportKeyPairResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportKeyPair">REST API Reference for ImportKeyPair Operation</seealso>
        public virtual ImportKeyPairResponse EndImportKeyPair(IAsyncResult asyncResult)
        {
            return EndInvoke<ImportKeyPairResponse>(asyncResult);
        }

        #endregion
        
        #region  ImportSnapshot

        /// <summary>
        /// Imports a disk into an EBS snapshot.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-import-snapshot.html">Importing
        /// a disk as a snapshot using VM Import/Export</a> in the <i>VM Import/Export User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ImportSnapshot service method.</param>
        /// 
        /// <returns>The response from the ImportSnapshot service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportSnapshot">REST API Reference for ImportSnapshot Operation</seealso>
        public virtual ImportSnapshotResponse ImportSnapshot(ImportSnapshotRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportSnapshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportSnapshotResponseUnmarshaller.Instance;

            return Invoke<ImportSnapshotResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ImportSnapshot operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ImportSnapshot operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndImportSnapshot
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportSnapshot">REST API Reference for ImportSnapshot Operation</seealso>
        public virtual IAsyncResult BeginImportSnapshot(ImportSnapshotRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportSnapshotRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportSnapshotResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ImportSnapshot operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginImportSnapshot.</param>
        /// 
        /// <returns>Returns a  ImportSnapshotResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportSnapshot">REST API Reference for ImportSnapshot Operation</seealso>
        public virtual ImportSnapshotResponse EndImportSnapshot(IAsyncResult asyncResult)
        {
            return EndInvoke<ImportSnapshotResponse>(asyncResult);
        }

        #endregion
        
        #region  ImportVolume

        /// <summary>
        /// Creates an import volume task using metadata from the specified disk image.
        /// 
        ///  
        /// <para>
        /// This API action supports only single-volume VMs. To import multi-volume VMs, use <a>ImportImage</a>
        /// instead. To import a disk to a snapshot, use <a>ImportSnapshot</a> instead.
        /// </para>
        ///  
        /// <para>
        /// This API action is not supported by the Command Line Interface (CLI). For information
        /// about using the Amazon EC2 CLI, which is deprecated, see <a href="https://awsdocs.s3.amazonaws.com/EC2/ec2-clt.pdf#importing-your-volumes-into-amazon-ebs">Importing
        /// Disks to Amazon EBS</a> in the <i>Amazon EC2 CLI Reference</i> PDF file.
        /// </para>
        ///  
        /// <para>
        /// For information about the import manifest referenced by this API action, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/manifest.html">VM
        /// Import Manifest</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ImportVolume service method.</param>
        /// 
        /// <returns>The response from the ImportVolume service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportVolume">REST API Reference for ImportVolume Operation</seealso>
        public virtual ImportVolumeResponse ImportVolume(ImportVolumeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportVolumeResponseUnmarshaller.Instance;

            return Invoke<ImportVolumeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ImportVolume operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ImportVolume operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndImportVolume
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportVolume">REST API Reference for ImportVolume Operation</seealso>
        public virtual IAsyncResult BeginImportVolume(ImportVolumeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ImportVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ImportVolumeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ImportVolume operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginImportVolume.</param>
        /// 
        /// <returns>Returns a  ImportVolumeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ImportVolume">REST API Reference for ImportVolume Operation</seealso>
        public virtual ImportVolumeResponse EndImportVolume(IAsyncResult asyncResult)
        {
            return EndInvoke<ImportVolumeResponse>(asyncResult);
        }

        #endregion
        
        #region  ListImagesInRecycleBin

        /// <summary>
        /// Lists one or more AMIs that are currently in the Recycle Bin. For more information,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin.html">Recycle
        /// Bin</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ListImagesInRecycleBin service method.</param>
        /// 
        /// <returns>The response from the ListImagesInRecycleBin service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ListImagesInRecycleBin">REST API Reference for ListImagesInRecycleBin Operation</seealso>
        public virtual ListImagesInRecycleBinResponse ListImagesInRecycleBin(ListImagesInRecycleBinRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListImagesInRecycleBinRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListImagesInRecycleBinResponseUnmarshaller.Instance;

            return Invoke<ListImagesInRecycleBinResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ListImagesInRecycleBin operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ListImagesInRecycleBin operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListImagesInRecycleBin
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ListImagesInRecycleBin">REST API Reference for ListImagesInRecycleBin Operation</seealso>
        public virtual IAsyncResult BeginListImagesInRecycleBin(ListImagesInRecycleBinRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListImagesInRecycleBinRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListImagesInRecycleBinResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ListImagesInRecycleBin operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginListImagesInRecycleBin.</param>
        /// 
        /// <returns>Returns a  ListImagesInRecycleBinResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ListImagesInRecycleBin">REST API Reference for ListImagesInRecycleBin Operation</seealso>
        public virtual ListImagesInRecycleBinResponse EndListImagesInRecycleBin(IAsyncResult asyncResult)
        {
            return EndInvoke<ListImagesInRecycleBinResponse>(asyncResult);
        }

        #endregion
        
        #region  ListSnapshotsInRecycleBin

        /// <summary>
        /// Lists one or more snapshots that are currently in the Recycle Bin.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ListSnapshotsInRecycleBin service method.</param>
        /// 
        /// <returns>The response from the ListSnapshotsInRecycleBin service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ListSnapshotsInRecycleBin">REST API Reference for ListSnapshotsInRecycleBin Operation</seealso>
        public virtual ListSnapshotsInRecycleBinResponse ListSnapshotsInRecycleBin(ListSnapshotsInRecycleBinRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListSnapshotsInRecycleBinRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListSnapshotsInRecycleBinResponseUnmarshaller.Instance;

            return Invoke<ListSnapshotsInRecycleBinResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ListSnapshotsInRecycleBin operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ListSnapshotsInRecycleBin operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListSnapshotsInRecycleBin
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ListSnapshotsInRecycleBin">REST API Reference for ListSnapshotsInRecycleBin Operation</seealso>
        public virtual IAsyncResult BeginListSnapshotsInRecycleBin(ListSnapshotsInRecycleBinRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ListSnapshotsInRecycleBinRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ListSnapshotsInRecycleBinResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ListSnapshotsInRecycleBin operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginListSnapshotsInRecycleBin.</param>
        /// 
        /// <returns>Returns a  ListSnapshotsInRecycleBinResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ListSnapshotsInRecycleBin">REST API Reference for ListSnapshotsInRecycleBin Operation</seealso>
        public virtual ListSnapshotsInRecycleBinResponse EndListSnapshotsInRecycleBin(IAsyncResult asyncResult)
        {
            return EndInvoke<ListSnapshotsInRecycleBinResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyAddressAttribute

        /// <summary>
        /// Modifies an attribute of the specified Elastic IP address. For requirements, see <a
        /// href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html#Using_Elastic_Addressing_Reverse_DNS">Using
        /// reverse DNS for email applications</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyAddressAttribute service method.</param>
        /// 
        /// <returns>The response from the ModifyAddressAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyAddressAttribute">REST API Reference for ModifyAddressAttribute Operation</seealso>
        public virtual ModifyAddressAttributeResponse ModifyAddressAttribute(ModifyAddressAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyAddressAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyAddressAttributeResponseUnmarshaller.Instance;

            return Invoke<ModifyAddressAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyAddressAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyAddressAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyAddressAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyAddressAttribute">REST API Reference for ModifyAddressAttribute Operation</seealso>
        public virtual IAsyncResult BeginModifyAddressAttribute(ModifyAddressAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyAddressAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyAddressAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyAddressAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyAddressAttribute.</param>
        /// 
        /// <returns>Returns a  ModifyAddressAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyAddressAttribute">REST API Reference for ModifyAddressAttribute Operation</seealso>
        public virtual ModifyAddressAttributeResponse EndModifyAddressAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyAddressAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyAvailabilityZoneGroup

        /// <summary>
        /// Changes the opt-in status of the Local Zone and Wavelength Zone group for your account.
        /// 
        ///  
        /// <para>
        /// Use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html">
        /// DescribeAvailabilityZones</a> to view the value for <code>GroupName</code>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyAvailabilityZoneGroup service method.</param>
        /// 
        /// <returns>The response from the ModifyAvailabilityZoneGroup service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyAvailabilityZoneGroup">REST API Reference for ModifyAvailabilityZoneGroup Operation</seealso>
        public virtual ModifyAvailabilityZoneGroupResponse ModifyAvailabilityZoneGroup(ModifyAvailabilityZoneGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyAvailabilityZoneGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyAvailabilityZoneGroupResponseUnmarshaller.Instance;

            return Invoke<ModifyAvailabilityZoneGroupResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyAvailabilityZoneGroup operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyAvailabilityZoneGroup operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyAvailabilityZoneGroup
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyAvailabilityZoneGroup">REST API Reference for ModifyAvailabilityZoneGroup Operation</seealso>
        public virtual IAsyncResult BeginModifyAvailabilityZoneGroup(ModifyAvailabilityZoneGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyAvailabilityZoneGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyAvailabilityZoneGroupResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyAvailabilityZoneGroup operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyAvailabilityZoneGroup.</param>
        /// 
        /// <returns>Returns a  ModifyAvailabilityZoneGroupResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyAvailabilityZoneGroup">REST API Reference for ModifyAvailabilityZoneGroup Operation</seealso>
        public virtual ModifyAvailabilityZoneGroupResponse EndModifyAvailabilityZoneGroup(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyAvailabilityZoneGroupResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyCapacityReservation

        /// <summary>
        /// Modifies a Capacity Reservation's capacity and the conditions under which it is to
        /// be released. You cannot change a Capacity Reservation's instance type, EBS optimization,
        /// instance store settings, platform, Availability Zone, or instance eligibility. If
        /// you need to modify any of these attributes, we recommend that you cancel the Capacity
        /// Reservation, and then create a new one with the required attributes.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyCapacityReservation service method.</param>
        /// 
        /// <returns>The response from the ModifyCapacityReservation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyCapacityReservation">REST API Reference for ModifyCapacityReservation Operation</seealso>
        public virtual ModifyCapacityReservationResponse ModifyCapacityReservation(ModifyCapacityReservationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyCapacityReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyCapacityReservationResponseUnmarshaller.Instance;

            return Invoke<ModifyCapacityReservationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyCapacityReservation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyCapacityReservation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyCapacityReservation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyCapacityReservation">REST API Reference for ModifyCapacityReservation Operation</seealso>
        public virtual IAsyncResult BeginModifyCapacityReservation(ModifyCapacityReservationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyCapacityReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyCapacityReservationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyCapacityReservation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyCapacityReservation.</param>
        /// 
        /// <returns>Returns a  ModifyCapacityReservationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyCapacityReservation">REST API Reference for ModifyCapacityReservation Operation</seealso>
        public virtual ModifyCapacityReservationResponse EndModifyCapacityReservation(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyCapacityReservationResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyCapacityReservationFleet

        /// <summary>
        /// Modifies a Capacity Reservation Fleet.
        /// 
        ///  
        /// <para>
        /// When you modify the total target capacity of a Capacity Reservation Fleet, the Fleet
        /// automatically creates new Capacity Reservations, or modifies or cancels existing Capacity
        /// Reservations in the Fleet to meet the new total target capacity. When you modify the
        /// end date for the Fleet, the end dates for all of the individual Capacity Reservations
        /// in the Fleet are updated accordingly.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyCapacityReservationFleet service method.</param>
        /// 
        /// <returns>The response from the ModifyCapacityReservationFleet service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyCapacityReservationFleet">REST API Reference for ModifyCapacityReservationFleet Operation</seealso>
        public virtual ModifyCapacityReservationFleetResponse ModifyCapacityReservationFleet(ModifyCapacityReservationFleetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyCapacityReservationFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyCapacityReservationFleetResponseUnmarshaller.Instance;

            return Invoke<ModifyCapacityReservationFleetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyCapacityReservationFleet operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyCapacityReservationFleet operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyCapacityReservationFleet
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyCapacityReservationFleet">REST API Reference for ModifyCapacityReservationFleet Operation</seealso>
        public virtual IAsyncResult BeginModifyCapacityReservationFleet(ModifyCapacityReservationFleetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyCapacityReservationFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyCapacityReservationFleetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyCapacityReservationFleet operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyCapacityReservationFleet.</param>
        /// 
        /// <returns>Returns a  ModifyCapacityReservationFleetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyCapacityReservationFleet">REST API Reference for ModifyCapacityReservationFleet Operation</seealso>
        public virtual ModifyCapacityReservationFleetResponse EndModifyCapacityReservationFleet(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyCapacityReservationFleetResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyClientVpnEndpoint

        /// <summary>
        /// Modifies the specified Client VPN endpoint. Modifying the DNS server resets existing
        /// client connections.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyClientVpnEndpoint service method.</param>
        /// 
        /// <returns>The response from the ModifyClientVpnEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyClientVpnEndpoint">REST API Reference for ModifyClientVpnEndpoint Operation</seealso>
        public virtual ModifyClientVpnEndpointResponse ModifyClientVpnEndpoint(ModifyClientVpnEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyClientVpnEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyClientVpnEndpointResponseUnmarshaller.Instance;

            return Invoke<ModifyClientVpnEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyClientVpnEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyClientVpnEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyClientVpnEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyClientVpnEndpoint">REST API Reference for ModifyClientVpnEndpoint Operation</seealso>
        public virtual IAsyncResult BeginModifyClientVpnEndpoint(ModifyClientVpnEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyClientVpnEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyClientVpnEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyClientVpnEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyClientVpnEndpoint.</param>
        /// 
        /// <returns>Returns a  ModifyClientVpnEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyClientVpnEndpoint">REST API Reference for ModifyClientVpnEndpoint Operation</seealso>
        public virtual ModifyClientVpnEndpointResponse EndModifyClientVpnEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyClientVpnEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyDefaultCreditSpecification

        /// <summary>
        /// Modifies the default credit option for CPU usage of burstable performance instances.
        /// The default credit option is set at the account level per Amazon Web Services Region,
        /// and is specified per instance family. All new burstable performance instances in the
        /// account launch using the default credit option.
        /// 
        ///  
        /// <para>
        ///  <code>ModifyDefaultCreditSpecification</code> is an asynchronous operation, which
        /// works at an Amazon Web Services Region level and modifies the credit option for each
        /// Availability Zone. All zones in a Region are updated within five minutes. But if instances
        /// are launched during this operation, they might not get the new credit option until
        /// the zone is updated. To verify whether the update has occurred, you can call <code>GetDefaultCreditSpecification</code>
        /// and check <code>DefaultCreditSpecification</code> for updates.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html">Burstable
        /// performance instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyDefaultCreditSpecification service method.</param>
        /// 
        /// <returns>The response from the ModifyDefaultCreditSpecification service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyDefaultCreditSpecification">REST API Reference for ModifyDefaultCreditSpecification Operation</seealso>
        public virtual ModifyDefaultCreditSpecificationResponse ModifyDefaultCreditSpecification(ModifyDefaultCreditSpecificationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyDefaultCreditSpecificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyDefaultCreditSpecificationResponseUnmarshaller.Instance;

            return Invoke<ModifyDefaultCreditSpecificationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyDefaultCreditSpecification operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyDefaultCreditSpecification operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyDefaultCreditSpecification
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyDefaultCreditSpecification">REST API Reference for ModifyDefaultCreditSpecification Operation</seealso>
        public virtual IAsyncResult BeginModifyDefaultCreditSpecification(ModifyDefaultCreditSpecificationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyDefaultCreditSpecificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyDefaultCreditSpecificationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyDefaultCreditSpecification operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyDefaultCreditSpecification.</param>
        /// 
        /// <returns>Returns a  ModifyDefaultCreditSpecificationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyDefaultCreditSpecification">REST API Reference for ModifyDefaultCreditSpecification Operation</seealso>
        public virtual ModifyDefaultCreditSpecificationResponse EndModifyDefaultCreditSpecification(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyDefaultCreditSpecificationResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyEbsDefaultKmsKeyId

        /// <summary>
        /// Changes the default KMS key for EBS encryption by default for your account in this
        /// Region.
        /// 
        ///  
        /// <para>
        /// Amazon Web Services creates a unique Amazon Web Services managed KMS key in each Region
        /// for use with encryption by default. If you change the default KMS key to a symmetric
        /// customer managed KMS key, it is used instead of the Amazon Web Services managed KMS
        /// key. To reset the default KMS key to the Amazon Web Services managed KMS key for EBS,
        /// use <a>ResetEbsDefaultKmsKeyId</a>. Amazon EBS does not support asymmetric KMS keys.
        /// </para>
        ///  
        /// <para>
        /// If you delete or disable the customer managed KMS key that you specified for use with
        /// encryption by default, your instances will fail to launch.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon
        /// EBS encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyEbsDefaultKmsKeyId service method.</param>
        /// 
        /// <returns>The response from the ModifyEbsDefaultKmsKeyId service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyEbsDefaultKmsKeyId">REST API Reference for ModifyEbsDefaultKmsKeyId Operation</seealso>
        public virtual ModifyEbsDefaultKmsKeyIdResponse ModifyEbsDefaultKmsKeyId(ModifyEbsDefaultKmsKeyIdRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyEbsDefaultKmsKeyIdRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyEbsDefaultKmsKeyIdResponseUnmarshaller.Instance;

            return Invoke<ModifyEbsDefaultKmsKeyIdResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyEbsDefaultKmsKeyId operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyEbsDefaultKmsKeyId operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyEbsDefaultKmsKeyId
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyEbsDefaultKmsKeyId">REST API Reference for ModifyEbsDefaultKmsKeyId Operation</seealso>
        public virtual IAsyncResult BeginModifyEbsDefaultKmsKeyId(ModifyEbsDefaultKmsKeyIdRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyEbsDefaultKmsKeyIdRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyEbsDefaultKmsKeyIdResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyEbsDefaultKmsKeyId operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyEbsDefaultKmsKeyId.</param>
        /// 
        /// <returns>Returns a  ModifyEbsDefaultKmsKeyIdResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyEbsDefaultKmsKeyId">REST API Reference for ModifyEbsDefaultKmsKeyId Operation</seealso>
        public virtual ModifyEbsDefaultKmsKeyIdResponse EndModifyEbsDefaultKmsKeyId(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyEbsDefaultKmsKeyIdResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyFleet

        /// <summary>
        /// Modifies the specified EC2 Fleet.
        /// 
        ///  
        /// <para>
        /// You can only modify an EC2 Fleet request of type <code>maintain</code>.
        /// </para>
        ///  
        /// <para>
        /// While the EC2 Fleet is being modified, it is in the <code>modifying</code> state.
        /// </para>
        ///  
        /// <para>
        /// To scale up your EC2 Fleet, increase its target capacity. The EC2 Fleet launches the
        /// additional Spot Instances according to the allocation strategy for the EC2 Fleet request.
        /// If the allocation strategy is <code>lowest-price</code>, the EC2 Fleet launches instances
        /// using the Spot Instance pool with the lowest price. If the allocation strategy is
        /// <code>diversified</code>, the EC2 Fleet distributes the instances across the Spot
        /// Instance pools. If the allocation strategy is <code>capacity-optimized</code>, EC2
        /// Fleet launches instances from Spot Instance pools with optimal capacity for the number
        /// of instances that are launching.
        /// </para>
        ///  
        /// <para>
        /// To scale down your EC2 Fleet, decrease its target capacity. First, the EC2 Fleet cancels
        /// any open requests that exceed the new target capacity. You can request that the EC2
        /// Fleet terminate Spot Instances until the size of the fleet no longer exceeds the new
        /// target capacity. If the allocation strategy is <code>lowest-price</code>, the EC2
        /// Fleet terminates the instances with the highest price per unit. If the allocation
        /// strategy is <code>capacity-optimized</code>, the EC2 Fleet terminates the instances
        /// in the Spot Instance pools that have the least available Spot Instance capacity. If
        /// the allocation strategy is <code>diversified</code>, the EC2 Fleet terminates instances
        /// across the Spot Instance pools. Alternatively, you can request that the EC2 Fleet
        /// keep the fleet at its current size, but not replace any Spot Instances that are interrupted
        /// or that you terminate manually.
        /// </para>
        ///  
        /// <para>
        /// If you are finished with your EC2 Fleet for now, but will use it again later, you
        /// can set the target capacity to 0.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyFleet service method.</param>
        /// 
        /// <returns>The response from the ModifyFleet service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyFleet">REST API Reference for ModifyFleet Operation</seealso>
        public virtual ModifyFleetResponse ModifyFleet(ModifyFleetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyFleetResponseUnmarshaller.Instance;

            return Invoke<ModifyFleetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyFleet operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyFleet operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyFleet
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyFleet">REST API Reference for ModifyFleet Operation</seealso>
        public virtual IAsyncResult BeginModifyFleet(ModifyFleetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyFleetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyFleet operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyFleet.</param>
        /// 
        /// <returns>Returns a  ModifyFleetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyFleet">REST API Reference for ModifyFleet Operation</seealso>
        public virtual ModifyFleetResponse EndModifyFleet(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyFleetResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyFpgaImageAttribute

        /// <summary>
        /// Modifies the specified attribute of the specified Amazon FPGA Image (AFI).
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyFpgaImageAttribute service method.</param>
        /// 
        /// <returns>The response from the ModifyFpgaImageAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyFpgaImageAttribute">REST API Reference for ModifyFpgaImageAttribute Operation</seealso>
        public virtual ModifyFpgaImageAttributeResponse ModifyFpgaImageAttribute(ModifyFpgaImageAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyFpgaImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyFpgaImageAttributeResponseUnmarshaller.Instance;

            return Invoke<ModifyFpgaImageAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyFpgaImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyFpgaImageAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyFpgaImageAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyFpgaImageAttribute">REST API Reference for ModifyFpgaImageAttribute Operation</seealso>
        public virtual IAsyncResult BeginModifyFpgaImageAttribute(ModifyFpgaImageAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyFpgaImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyFpgaImageAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyFpgaImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyFpgaImageAttribute.</param>
        /// 
        /// <returns>Returns a  ModifyFpgaImageAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyFpgaImageAttribute">REST API Reference for ModifyFpgaImageAttribute Operation</seealso>
        public virtual ModifyFpgaImageAttributeResponse EndModifyFpgaImageAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyFpgaImageAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyHosts

        /// <summary>
        /// Modify the auto-placement setting of a Dedicated Host. When auto-placement is enabled,
        /// any instances that you launch with a tenancy of <code>host</code> but without a specific
        /// host ID are placed onto any available Dedicated Host in your account that has auto-placement
        /// enabled. When auto-placement is disabled, you need to provide a host ID to have the
        /// instance launch onto a specific host. If no host ID is provided, the instance is launched
        /// onto a suitable host with auto-placement enabled.
        /// 
        ///  
        /// <para>
        /// You can also use this API action to modify a Dedicated Host to support either multiple
        /// instance types in an instance family, or to support a specific instance type only.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyHosts service method.</param>
        /// 
        /// <returns>The response from the ModifyHosts service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyHosts">REST API Reference for ModifyHosts Operation</seealso>
        public virtual ModifyHostsResponse ModifyHosts(ModifyHostsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyHostsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyHostsResponseUnmarshaller.Instance;

            return Invoke<ModifyHostsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyHosts operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyHosts operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyHosts
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyHosts">REST API Reference for ModifyHosts Operation</seealso>
        public virtual IAsyncResult BeginModifyHosts(ModifyHostsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyHostsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyHostsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyHosts operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyHosts.</param>
        /// 
        /// <returns>Returns a  ModifyHostsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyHosts">REST API Reference for ModifyHosts Operation</seealso>
        public virtual ModifyHostsResponse EndModifyHosts(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyHostsResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyIdentityIdFormat

        /// <summary>
        /// Modifies the ID format of a resource for a specified IAM user, IAM role, or the root
        /// user for an account; or all IAM users, IAM roles, and the root user for an account.
        /// You can specify that resources should receive longer IDs (17-character IDs) when they
        /// are created. 
        /// 
        ///  
        /// <para>
        /// This request can only be used to modify longer ID settings for resource types that
        /// are within the opt-in period. Resources currently in their opt-in period include:
        /// <code>bundle</code> | <code>conversion-task</code> | <code>customer-gateway</code>
        /// | <code>dhcp-options</code> | <code>elastic-ip-allocation</code> | <code>elastic-ip-association</code>
        /// | <code>export-task</code> | <code>flow-log</code> | <code>image</code> | <code>import-task</code>
        /// | <code>internet-gateway</code> | <code>network-acl</code> | <code>network-acl-association</code>
        /// | <code>network-interface</code> | <code>network-interface-attachment</code> | <code>prefix-list</code>
        /// | <code>route-table</code> | <code>route-table-association</code> | <code>security-group</code>
        /// | <code>subnet</code> | <code>subnet-cidr-block-association</code> | <code>vpc</code>
        /// | <code>vpc-cidr-block-association</code> | <code>vpc-endpoint</code> | <code>vpc-peering-connection</code>
        /// | <code>vpn-connection</code> | <code>vpn-gateway</code>. 
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/resource-ids.html">Resource
        /// IDs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>. 
        /// </para>
        ///  
        /// <para>
        /// This setting applies to the principal specified in the request; it does not apply
        /// to the principal that makes the request. 
        /// </para>
        ///  
        /// <para>
        /// Resources created with longer IDs are visible to all IAM roles and users, regardless
        /// of these settings and provided that they have permission to use the relevant <code>Describe</code>
        /// command for the resource type.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyIdentityIdFormat service method.</param>
        /// 
        /// <returns>The response from the ModifyIdentityIdFormat service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIdentityIdFormat">REST API Reference for ModifyIdentityIdFormat Operation</seealso>
        public virtual ModifyIdentityIdFormatResponse ModifyIdentityIdFormat(ModifyIdentityIdFormatRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIdentityIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIdentityIdFormatResponseUnmarshaller.Instance;

            return Invoke<ModifyIdentityIdFormatResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyIdentityIdFormat operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyIdentityIdFormat operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyIdentityIdFormat
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIdentityIdFormat">REST API Reference for ModifyIdentityIdFormat Operation</seealso>
        public virtual IAsyncResult BeginModifyIdentityIdFormat(ModifyIdentityIdFormatRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIdentityIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIdentityIdFormatResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyIdentityIdFormat operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyIdentityIdFormat.</param>
        /// 
        /// <returns>Returns a  ModifyIdentityIdFormatResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIdentityIdFormat">REST API Reference for ModifyIdentityIdFormat Operation</seealso>
        public virtual ModifyIdentityIdFormatResponse EndModifyIdentityIdFormat(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyIdentityIdFormatResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyIdFormat

        /// <summary>
        /// Modifies the ID format for the specified resource on a per-Region basis. You can specify
        /// that resources should receive longer IDs (17-character IDs) when they are created.
        /// 
        ///  
        /// <para>
        /// This request can only be used to modify longer ID settings for resource types that
        /// are within the opt-in period. Resources currently in their opt-in period include:
        /// <code>bundle</code> | <code>conversion-task</code> | <code>customer-gateway</code>
        /// | <code>dhcp-options</code> | <code>elastic-ip-allocation</code> | <code>elastic-ip-association</code>
        /// | <code>export-task</code> | <code>flow-log</code> | <code>image</code> | <code>import-task</code>
        /// | <code>internet-gateway</code> | <code>network-acl</code> | <code>network-acl-association</code>
        /// | <code>network-interface</code> | <code>network-interface-attachment</code> | <code>prefix-list</code>
        /// | <code>route-table</code> | <code>route-table-association</code> | <code>security-group</code>
        /// | <code>subnet</code> | <code>subnet-cidr-block-association</code> | <code>vpc</code>
        /// | <code>vpc-cidr-block-association</code> | <code>vpc-endpoint</code> | <code>vpc-peering-connection</code>
        /// | <code>vpn-connection</code> | <code>vpn-gateway</code>.
        /// </para>
        ///  
        /// <para>
        /// This setting applies to the IAM user who makes the request; it does not apply to the
        /// entire Amazon Web Services account. By default, an IAM user defaults to the same settings
        /// as the root user. If you're using this action as the root user, then these settings
        /// apply to the entire account, unless an IAM user explicitly overrides these settings
        /// for themselves. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/resource-ids.html">Resource
        /// IDs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// Resources created with longer IDs are visible to all IAM roles and users, regardless
        /// of these settings and provided that they have permission to use the relevant <code>Describe</code>
        /// command for the resource type.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyIdFormat service method.</param>
        /// 
        /// <returns>The response from the ModifyIdFormat service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIdFormat">REST API Reference for ModifyIdFormat Operation</seealso>
        public virtual ModifyIdFormatResponse ModifyIdFormat(ModifyIdFormatRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIdFormatResponseUnmarshaller.Instance;

            return Invoke<ModifyIdFormatResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyIdFormat operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyIdFormat operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyIdFormat
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIdFormat">REST API Reference for ModifyIdFormat Operation</seealso>
        public virtual IAsyncResult BeginModifyIdFormat(ModifyIdFormatRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIdFormatRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIdFormatResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyIdFormat operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyIdFormat.</param>
        /// 
        /// <returns>Returns a  ModifyIdFormatResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIdFormat">REST API Reference for ModifyIdFormat Operation</seealso>
        public virtual ModifyIdFormatResponse EndModifyIdFormat(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyIdFormatResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyImageAttribute

        /// <summary>
        /// Modifies the specified attribute of the specified AMI. You can specify only one attribute
        /// at a time.
        /// 
        ///  
        /// <para>
        /// To specify the attribute, you can use the <code>Attribute</code> parameter, or one
        /// of the following parameters: <code>Description</code>, <code>ImdsSupport</code>, or
        /// <code>LaunchPermission</code>.
        /// </para>
        ///  
        /// <para>
        /// Images with an Amazon Web Services Marketplace product code cannot be made public.
        /// </para>
        ///  
        /// <para>
        /// To enable the SriovNetSupport enhanced networking attribute of an image, enable SriovNetSupport
        /// on an instance and create an AMI from the instance.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyImageAttribute service method.</param>
        /// 
        /// <returns>The response from the ModifyImageAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyImageAttribute">REST API Reference for ModifyImageAttribute Operation</seealso>
        public virtual ModifyImageAttributeResponse ModifyImageAttribute(ModifyImageAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyImageAttributeResponseUnmarshaller.Instance;

            return Invoke<ModifyImageAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyImageAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyImageAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyImageAttribute">REST API Reference for ModifyImageAttribute Operation</seealso>
        public virtual IAsyncResult BeginModifyImageAttribute(ModifyImageAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyImageAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyImageAttribute.</param>
        /// 
        /// <returns>Returns a  ModifyImageAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyImageAttribute">REST API Reference for ModifyImageAttribute Operation</seealso>
        public virtual ModifyImageAttributeResponse EndModifyImageAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyImageAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyInstanceAttribute

        /// <summary>
        /// Modifies the specified attribute of the specified instance. You can specify only one
        /// attribute at a time.
        /// 
        ///  
        /// <para>
        ///  <b>Note: </b>Using this action to change the security groups associated with an elastic
        /// network interface (ENI) attached to an instance can result in an error if the instance
        /// has more than one ENI. To change the security groups associated with an ENI attached
        /// to an instance that has multiple ENIs, we recommend that you use the <a>ModifyNetworkInterfaceAttribute</a>
        /// action.
        /// </para>
        ///  
        /// <para>
        /// To modify some attributes, the instance must be stopped. For more information, see
        /// <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_ChangingAttributesWhileInstanceStopped.html">Modify
        /// a stopped instance</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceAttribute service method.</param>
        /// 
        /// <returns>The response from the ModifyInstanceAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceAttribute">REST API Reference for ModifyInstanceAttribute Operation</seealso>
        public virtual ModifyInstanceAttributeResponse ModifyInstanceAttribute(ModifyInstanceAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceAttributeResponseUnmarshaller.Instance;

            return Invoke<ModifyInstanceAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyInstanceAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyInstanceAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceAttribute">REST API Reference for ModifyInstanceAttribute Operation</seealso>
        public virtual IAsyncResult BeginModifyInstanceAttribute(ModifyInstanceAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyInstanceAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyInstanceAttribute.</param>
        /// 
        /// <returns>Returns a  ModifyInstanceAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceAttribute">REST API Reference for ModifyInstanceAttribute Operation</seealso>
        public virtual ModifyInstanceAttributeResponse EndModifyInstanceAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyInstanceAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyInstanceCapacityReservationAttributes

        /// <summary>
        /// Modifies the Capacity Reservation settings for a stopped instance. Use this action
        /// to configure an instance to target a specific Capacity Reservation, run in any <code>open</code>
        /// Capacity Reservation with matching attributes, or run On-Demand Instance capacity.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceCapacityReservationAttributes service method.</param>
        /// 
        /// <returns>The response from the ModifyInstanceCapacityReservationAttributes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceCapacityReservationAttributes">REST API Reference for ModifyInstanceCapacityReservationAttributes Operation</seealso>
        public virtual ModifyInstanceCapacityReservationAttributesResponse ModifyInstanceCapacityReservationAttributes(ModifyInstanceCapacityReservationAttributesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceCapacityReservationAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceCapacityReservationAttributesResponseUnmarshaller.Instance;

            return Invoke<ModifyInstanceCapacityReservationAttributesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyInstanceCapacityReservationAttributes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceCapacityReservationAttributes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyInstanceCapacityReservationAttributes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceCapacityReservationAttributes">REST API Reference for ModifyInstanceCapacityReservationAttributes Operation</seealso>
        public virtual IAsyncResult BeginModifyInstanceCapacityReservationAttributes(ModifyInstanceCapacityReservationAttributesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceCapacityReservationAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceCapacityReservationAttributesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyInstanceCapacityReservationAttributes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyInstanceCapacityReservationAttributes.</param>
        /// 
        /// <returns>Returns a  ModifyInstanceCapacityReservationAttributesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceCapacityReservationAttributes">REST API Reference for ModifyInstanceCapacityReservationAttributes Operation</seealso>
        public virtual ModifyInstanceCapacityReservationAttributesResponse EndModifyInstanceCapacityReservationAttributes(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyInstanceCapacityReservationAttributesResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyInstanceCreditSpecification

        /// <summary>
        /// Modifies the credit option for CPU usage on a running or stopped burstable performance
        /// instance. The credit options are <code>standard</code> and <code>unlimited</code>.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/burstable-performance-instances.html">Burstable
        /// performance instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceCreditSpecification service method.</param>
        /// 
        /// <returns>The response from the ModifyInstanceCreditSpecification service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceCreditSpecification">REST API Reference for ModifyInstanceCreditSpecification Operation</seealso>
        public virtual ModifyInstanceCreditSpecificationResponse ModifyInstanceCreditSpecification(ModifyInstanceCreditSpecificationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceCreditSpecificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceCreditSpecificationResponseUnmarshaller.Instance;

            return Invoke<ModifyInstanceCreditSpecificationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyInstanceCreditSpecification operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceCreditSpecification operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyInstanceCreditSpecification
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceCreditSpecification">REST API Reference for ModifyInstanceCreditSpecification Operation</seealso>
        public virtual IAsyncResult BeginModifyInstanceCreditSpecification(ModifyInstanceCreditSpecificationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceCreditSpecificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceCreditSpecificationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyInstanceCreditSpecification operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyInstanceCreditSpecification.</param>
        /// 
        /// <returns>Returns a  ModifyInstanceCreditSpecificationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceCreditSpecification">REST API Reference for ModifyInstanceCreditSpecification Operation</seealso>
        public virtual ModifyInstanceCreditSpecificationResponse EndModifyInstanceCreditSpecification(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyInstanceCreditSpecificationResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyInstanceEventStartTime

        /// <summary>
        /// Modifies the start time for a scheduled Amazon EC2 instance event.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceEventStartTime service method.</param>
        /// 
        /// <returns>The response from the ModifyInstanceEventStartTime service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceEventStartTime">REST API Reference for ModifyInstanceEventStartTime Operation</seealso>
        public virtual ModifyInstanceEventStartTimeResponse ModifyInstanceEventStartTime(ModifyInstanceEventStartTimeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceEventStartTimeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceEventStartTimeResponseUnmarshaller.Instance;

            return Invoke<ModifyInstanceEventStartTimeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyInstanceEventStartTime operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceEventStartTime operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyInstanceEventStartTime
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceEventStartTime">REST API Reference for ModifyInstanceEventStartTime Operation</seealso>
        public virtual IAsyncResult BeginModifyInstanceEventStartTime(ModifyInstanceEventStartTimeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceEventStartTimeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceEventStartTimeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyInstanceEventStartTime operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyInstanceEventStartTime.</param>
        /// 
        /// <returns>Returns a  ModifyInstanceEventStartTimeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceEventStartTime">REST API Reference for ModifyInstanceEventStartTime Operation</seealso>
        public virtual ModifyInstanceEventStartTimeResponse EndModifyInstanceEventStartTime(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyInstanceEventStartTimeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyInstanceEventWindow

        /// <summary>
        /// Modifies the specified event window.
        /// 
        ///  
        /// <para>
        /// You can define either a set of time ranges or a cron expression when modifying the
        /// event window, but not both.
        /// </para>
        ///  
        /// <para>
        /// To modify the targets associated with the event window, use the <a>AssociateInstanceEventWindow</a>
        /// and <a>DisassociateInstanceEventWindow</a> API.
        /// </para>
        ///  
        /// <para>
        /// If Amazon Web Services has already scheduled an event, modifying an event window won't
        /// change the time of the scheduled event.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/event-windows.html">Define
        /// event windows for scheduled events</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceEventWindow service method.</param>
        /// 
        /// <returns>The response from the ModifyInstanceEventWindow service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceEventWindow">REST API Reference for ModifyInstanceEventWindow Operation</seealso>
        public virtual ModifyInstanceEventWindowResponse ModifyInstanceEventWindow(ModifyInstanceEventWindowRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceEventWindowResponseUnmarshaller.Instance;

            return Invoke<ModifyInstanceEventWindowResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceEventWindow operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyInstanceEventWindow
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceEventWindow">REST API Reference for ModifyInstanceEventWindow Operation</seealso>
        public virtual IAsyncResult BeginModifyInstanceEventWindow(ModifyInstanceEventWindowRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceEventWindowRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceEventWindowResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyInstanceEventWindow operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyInstanceEventWindow.</param>
        /// 
        /// <returns>Returns a  ModifyInstanceEventWindowResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceEventWindow">REST API Reference for ModifyInstanceEventWindow Operation</seealso>
        public virtual ModifyInstanceEventWindowResponse EndModifyInstanceEventWindow(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyInstanceEventWindowResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyInstanceMaintenanceOptions

        /// <summary>
        /// Modifies the recovery behavior of your instance to disable simplified automatic recovery
        /// or set the recovery behavior to default. The default configuration will not enable
        /// simplified automatic recovery for an unsupported instance type. For more information,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-recover.html#instance-configuration-recovery">Simplified
        /// automatic recovery</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceMaintenanceOptions service method.</param>
        /// 
        /// <returns>The response from the ModifyInstanceMaintenanceOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceMaintenanceOptions">REST API Reference for ModifyInstanceMaintenanceOptions Operation</seealso>
        public virtual ModifyInstanceMaintenanceOptionsResponse ModifyInstanceMaintenanceOptions(ModifyInstanceMaintenanceOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceMaintenanceOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceMaintenanceOptionsResponseUnmarshaller.Instance;

            return Invoke<ModifyInstanceMaintenanceOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyInstanceMaintenanceOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceMaintenanceOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyInstanceMaintenanceOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceMaintenanceOptions">REST API Reference for ModifyInstanceMaintenanceOptions Operation</seealso>
        public virtual IAsyncResult BeginModifyInstanceMaintenanceOptions(ModifyInstanceMaintenanceOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceMaintenanceOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceMaintenanceOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyInstanceMaintenanceOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyInstanceMaintenanceOptions.</param>
        /// 
        /// <returns>Returns a  ModifyInstanceMaintenanceOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceMaintenanceOptions">REST API Reference for ModifyInstanceMaintenanceOptions Operation</seealso>
        public virtual ModifyInstanceMaintenanceOptionsResponse EndModifyInstanceMaintenanceOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyInstanceMaintenanceOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyInstanceMetadataOptions

        /// <summary>
        /// Modify the instance metadata parameters on a running or stopped instance. When you
        /// modify the parameters on a stopped instance, they are applied when the instance is
        /// started. When you modify the parameters on a running instance, the API responds with
        /// a state of “pending”. After the parameter modifications are successfully applied to
        /// the instance, the state of the modifications changes from “pending” to “applied” in
        /// subsequent describe-instances API calls. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html">Instance
        /// metadata and user data</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceMetadataOptions service method.</param>
        /// 
        /// <returns>The response from the ModifyInstanceMetadataOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceMetadataOptions">REST API Reference for ModifyInstanceMetadataOptions Operation</seealso>
        public virtual ModifyInstanceMetadataOptionsResponse ModifyInstanceMetadataOptions(ModifyInstanceMetadataOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceMetadataOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceMetadataOptionsResponseUnmarshaller.Instance;

            return Invoke<ModifyInstanceMetadataOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyInstanceMetadataOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstanceMetadataOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyInstanceMetadataOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceMetadataOptions">REST API Reference for ModifyInstanceMetadataOptions Operation</seealso>
        public virtual IAsyncResult BeginModifyInstanceMetadataOptions(ModifyInstanceMetadataOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstanceMetadataOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstanceMetadataOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyInstanceMetadataOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyInstanceMetadataOptions.</param>
        /// 
        /// <returns>Returns a  ModifyInstanceMetadataOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstanceMetadataOptions">REST API Reference for ModifyInstanceMetadataOptions Operation</seealso>
        public virtual ModifyInstanceMetadataOptionsResponse EndModifyInstanceMetadataOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyInstanceMetadataOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyInstancePlacement

        /// <summary>
        /// Modifies the placement attributes for a specified instance. You can do the following:
        /// 
        ///  <ul> <li> 
        /// <para>
        /// Modify the affinity between an instance and a <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-hosts-overview.html">Dedicated
        /// Host</a>. When affinity is set to <code>host</code> and the instance is not associated
        /// with a specific Dedicated Host, the next time the instance is launched, it is automatically
        /// associated with the host on which it lands. If the instance is restarted or rebooted,
        /// this relationship persists.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Change the Dedicated Host with which an instance is associated.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Change the instance tenancy of an instance.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Move an instance to or from a <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html">placement
        /// group</a>.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// At least one attribute for affinity, host ID, tenancy, or placement group name must
        /// be specified in the request. Affinity and tenancy can be modified in the same request.
        /// </para>
        ///  
        /// <para>
        /// To modify the host ID, tenancy, placement group, or partition for an instance, the
        /// instance must be in the <code>stopped</code> state.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstancePlacement service method.</param>
        /// 
        /// <returns>The response from the ModifyInstancePlacement service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstancePlacement">REST API Reference for ModifyInstancePlacement Operation</seealso>
        public virtual ModifyInstancePlacementResponse ModifyInstancePlacement(ModifyInstancePlacementRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstancePlacementRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstancePlacementResponseUnmarshaller.Instance;

            return Invoke<ModifyInstancePlacementResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyInstancePlacement operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyInstancePlacement operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyInstancePlacement
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstancePlacement">REST API Reference for ModifyInstancePlacement Operation</seealso>
        public virtual IAsyncResult BeginModifyInstancePlacement(ModifyInstancePlacementRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyInstancePlacementRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyInstancePlacementResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyInstancePlacement operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyInstancePlacement.</param>
        /// 
        /// <returns>Returns a  ModifyInstancePlacementResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyInstancePlacement">REST API Reference for ModifyInstancePlacement Operation</seealso>
        public virtual ModifyInstancePlacementResponse EndModifyInstancePlacement(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyInstancePlacementResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyIpam

        /// <summary>
        /// Modify the configurations of an IPAM.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpam service method.</param>
        /// 
        /// <returns>The response from the ModifyIpam service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpam">REST API Reference for ModifyIpam Operation</seealso>
        public virtual ModifyIpamResponse ModifyIpam(ModifyIpamRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamResponseUnmarshaller.Instance;

            return Invoke<ModifyIpamResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyIpam operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpam operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyIpam
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpam">REST API Reference for ModifyIpam Operation</seealso>
        public virtual IAsyncResult BeginModifyIpam(ModifyIpamRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyIpam operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyIpam.</param>
        /// 
        /// <returns>Returns a  ModifyIpamResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpam">REST API Reference for ModifyIpam Operation</seealso>
        public virtual ModifyIpamResponse EndModifyIpam(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyIpamResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyIpamPool

        /// <summary>
        /// Modify the configurations of an IPAM pool.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/mod-pool-ipam.html">Modify
        /// a pool</a> in the <i>Amazon VPC IPAM User Guide</i>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpamPool service method.</param>
        /// 
        /// <returns>The response from the ModifyIpamPool service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamPool">REST API Reference for ModifyIpamPool Operation</seealso>
        public virtual ModifyIpamPoolResponse ModifyIpamPool(ModifyIpamPoolRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamPoolResponseUnmarshaller.Instance;

            return Invoke<ModifyIpamPoolResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyIpamPool operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpamPool operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyIpamPool
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamPool">REST API Reference for ModifyIpamPool Operation</seealso>
        public virtual IAsyncResult BeginModifyIpamPool(ModifyIpamPoolRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamPoolRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamPoolResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyIpamPool operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyIpamPool.</param>
        /// 
        /// <returns>Returns a  ModifyIpamPoolResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamPool">REST API Reference for ModifyIpamPool Operation</seealso>
        public virtual ModifyIpamPoolResponse EndModifyIpamPool(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyIpamPoolResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyIpamResourceCidr

        /// <summary>
        /// Modify a resource CIDR. You can use this action to transfer resource CIDRs between
        /// scopes and ignore resource CIDRs that you do not want to manage. If set to false,
        /// the resource will not be tracked for overlap, it cannot be auto-imported into a pool,
        /// and it will be removed from any pool it has an allocation in.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/move-resource-ipam.html">Move
        /// resource CIDRs between scopes</a> and <a href="https://docs.aws.amazon.com/vpc/latest/ipam/change-monitoring-state-ipam.html">Change
        /// the monitoring state of resource CIDRs</a> in the <i>Amazon VPC IPAM User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpamResourceCidr service method.</param>
        /// 
        /// <returns>The response from the ModifyIpamResourceCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamResourceCidr">REST API Reference for ModifyIpamResourceCidr Operation</seealso>
        public virtual ModifyIpamResourceCidrResponse ModifyIpamResourceCidr(ModifyIpamResourceCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamResourceCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamResourceCidrResponseUnmarshaller.Instance;

            return Invoke<ModifyIpamResourceCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyIpamResourceCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpamResourceCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyIpamResourceCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamResourceCidr">REST API Reference for ModifyIpamResourceCidr Operation</seealso>
        public virtual IAsyncResult BeginModifyIpamResourceCidr(ModifyIpamResourceCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamResourceCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamResourceCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyIpamResourceCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyIpamResourceCidr.</param>
        /// 
        /// <returns>Returns a  ModifyIpamResourceCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamResourceCidr">REST API Reference for ModifyIpamResourceCidr Operation</seealso>
        public virtual ModifyIpamResourceCidrResponse EndModifyIpamResourceCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyIpamResourceCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyIpamResourceDiscovery

        /// <summary>
        /// Modifies a resource discovery. A resource discovery is an IPAM component that enables
        /// IPAM to manage and monitor resources that belong to the owning account.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpamResourceDiscovery service method.</param>
        /// 
        /// <returns>The response from the ModifyIpamResourceDiscovery service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamResourceDiscovery">REST API Reference for ModifyIpamResourceDiscovery Operation</seealso>
        public virtual ModifyIpamResourceDiscoveryResponse ModifyIpamResourceDiscovery(ModifyIpamResourceDiscoveryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return Invoke<ModifyIpamResourceDiscoveryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpamResourceDiscovery operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyIpamResourceDiscovery
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamResourceDiscovery">REST API Reference for ModifyIpamResourceDiscovery Operation</seealso>
        public virtual IAsyncResult BeginModifyIpamResourceDiscovery(ModifyIpamResourceDiscoveryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamResourceDiscoveryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamResourceDiscoveryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyIpamResourceDiscovery operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyIpamResourceDiscovery.</param>
        /// 
        /// <returns>Returns a  ModifyIpamResourceDiscoveryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamResourceDiscovery">REST API Reference for ModifyIpamResourceDiscovery Operation</seealso>
        public virtual ModifyIpamResourceDiscoveryResponse EndModifyIpamResourceDiscovery(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyIpamResourceDiscoveryResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyIpamScope

        /// <summary>
        /// Modify an IPAM scope.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpamScope service method.</param>
        /// 
        /// <returns>The response from the ModifyIpamScope service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamScope">REST API Reference for ModifyIpamScope Operation</seealso>
        public virtual ModifyIpamScopeResponse ModifyIpamScope(ModifyIpamScopeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamScopeResponseUnmarshaller.Instance;

            return Invoke<ModifyIpamScopeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyIpamScope operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyIpamScope operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyIpamScope
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamScope">REST API Reference for ModifyIpamScope Operation</seealso>
        public virtual IAsyncResult BeginModifyIpamScope(ModifyIpamScopeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyIpamScopeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyIpamScopeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyIpamScope operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyIpamScope.</param>
        /// 
        /// <returns>Returns a  ModifyIpamScopeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyIpamScope">REST API Reference for ModifyIpamScope Operation</seealso>
        public virtual ModifyIpamScopeResponse EndModifyIpamScope(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyIpamScopeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyLaunchTemplate

        /// <summary>
        /// Modifies a launch template. You can specify which version of the launch template to
        /// set as the default version. When launching an instance, the default version applies
        /// when a launch template version is not specified.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyLaunchTemplate service method.</param>
        /// 
        /// <returns>The response from the ModifyLaunchTemplate service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyLaunchTemplate">REST API Reference for ModifyLaunchTemplate Operation</seealso>
        public virtual ModifyLaunchTemplateResponse ModifyLaunchTemplate(ModifyLaunchTemplateRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyLaunchTemplateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyLaunchTemplateResponseUnmarshaller.Instance;

            return Invoke<ModifyLaunchTemplateResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyLaunchTemplate operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyLaunchTemplate operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyLaunchTemplate
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyLaunchTemplate">REST API Reference for ModifyLaunchTemplate Operation</seealso>
        public virtual IAsyncResult BeginModifyLaunchTemplate(ModifyLaunchTemplateRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyLaunchTemplateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyLaunchTemplateResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyLaunchTemplate operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyLaunchTemplate.</param>
        /// 
        /// <returns>Returns a  ModifyLaunchTemplateResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyLaunchTemplate">REST API Reference for ModifyLaunchTemplate Operation</seealso>
        public virtual ModifyLaunchTemplateResponse EndModifyLaunchTemplate(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyLaunchTemplateResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyLocalGatewayRoute

        /// <summary>
        /// Modifies the specified local gateway route.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyLocalGatewayRoute service method.</param>
        /// 
        /// <returns>The response from the ModifyLocalGatewayRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyLocalGatewayRoute">REST API Reference for ModifyLocalGatewayRoute Operation</seealso>
        public virtual ModifyLocalGatewayRouteResponse ModifyLocalGatewayRoute(ModifyLocalGatewayRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyLocalGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyLocalGatewayRouteResponseUnmarshaller.Instance;

            return Invoke<ModifyLocalGatewayRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyLocalGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyLocalGatewayRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyLocalGatewayRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyLocalGatewayRoute">REST API Reference for ModifyLocalGatewayRoute Operation</seealso>
        public virtual IAsyncResult BeginModifyLocalGatewayRoute(ModifyLocalGatewayRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyLocalGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyLocalGatewayRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyLocalGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyLocalGatewayRoute.</param>
        /// 
        /// <returns>Returns a  ModifyLocalGatewayRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyLocalGatewayRoute">REST API Reference for ModifyLocalGatewayRoute Operation</seealso>
        public virtual ModifyLocalGatewayRouteResponse EndModifyLocalGatewayRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyLocalGatewayRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyManagedPrefixList

        /// <summary>
        /// Modifies the specified managed prefix list.
        /// 
        ///  
        /// <para>
        /// Adding or removing entries in a prefix list creates a new version of the prefix list.
        /// Changing the name of the prefix list does not affect the version.
        /// </para>
        ///  
        /// <para>
        /// If you specify a current version number that does not match the true current version
        /// number, the request fails.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyManagedPrefixList service method.</param>
        /// 
        /// <returns>The response from the ModifyManagedPrefixList service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyManagedPrefixList">REST API Reference for ModifyManagedPrefixList Operation</seealso>
        public virtual ModifyManagedPrefixListResponse ModifyManagedPrefixList(ModifyManagedPrefixListRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyManagedPrefixListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyManagedPrefixListResponseUnmarshaller.Instance;

            return Invoke<ModifyManagedPrefixListResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyManagedPrefixList operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyManagedPrefixList operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyManagedPrefixList
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyManagedPrefixList">REST API Reference for ModifyManagedPrefixList Operation</seealso>
        public virtual IAsyncResult BeginModifyManagedPrefixList(ModifyManagedPrefixListRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyManagedPrefixListRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyManagedPrefixListResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyManagedPrefixList operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyManagedPrefixList.</param>
        /// 
        /// <returns>Returns a  ModifyManagedPrefixListResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyManagedPrefixList">REST API Reference for ModifyManagedPrefixList Operation</seealso>
        public virtual ModifyManagedPrefixListResponse EndModifyManagedPrefixList(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyManagedPrefixListResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyNetworkInterfaceAttribute

        /// <summary>
        /// Modifies the specified network interface attribute. You can specify only one attribute
        /// at a time. You can use this action to attach and detach security groups from an existing
        /// EC2 instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyNetworkInterfaceAttribute service method.</param>
        /// 
        /// <returns>The response from the ModifyNetworkInterfaceAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyNetworkInterfaceAttribute">REST API Reference for ModifyNetworkInterfaceAttribute Operation</seealso>
        public virtual ModifyNetworkInterfaceAttributeResponse ModifyNetworkInterfaceAttribute(ModifyNetworkInterfaceAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyNetworkInterfaceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyNetworkInterfaceAttributeResponseUnmarshaller.Instance;

            return Invoke<ModifyNetworkInterfaceAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyNetworkInterfaceAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyNetworkInterfaceAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyNetworkInterfaceAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyNetworkInterfaceAttribute">REST API Reference for ModifyNetworkInterfaceAttribute Operation</seealso>
        public virtual IAsyncResult BeginModifyNetworkInterfaceAttribute(ModifyNetworkInterfaceAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyNetworkInterfaceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyNetworkInterfaceAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyNetworkInterfaceAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyNetworkInterfaceAttribute.</param>
        /// 
        /// <returns>Returns a  ModifyNetworkInterfaceAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyNetworkInterfaceAttribute">REST API Reference for ModifyNetworkInterfaceAttribute Operation</seealso>
        public virtual ModifyNetworkInterfaceAttributeResponse EndModifyNetworkInterfaceAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyNetworkInterfaceAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyPrivateDnsNameOptions

        /// <summary>
        /// Modifies the options for instance hostnames for the specified instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyPrivateDnsNameOptions service method.</param>
        /// 
        /// <returns>The response from the ModifyPrivateDnsNameOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyPrivateDnsNameOptions">REST API Reference for ModifyPrivateDnsNameOptions Operation</seealso>
        public virtual ModifyPrivateDnsNameOptionsResponse ModifyPrivateDnsNameOptions(ModifyPrivateDnsNameOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyPrivateDnsNameOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyPrivateDnsNameOptionsResponseUnmarshaller.Instance;

            return Invoke<ModifyPrivateDnsNameOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyPrivateDnsNameOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyPrivateDnsNameOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyPrivateDnsNameOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyPrivateDnsNameOptions">REST API Reference for ModifyPrivateDnsNameOptions Operation</seealso>
        public virtual IAsyncResult BeginModifyPrivateDnsNameOptions(ModifyPrivateDnsNameOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyPrivateDnsNameOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyPrivateDnsNameOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyPrivateDnsNameOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyPrivateDnsNameOptions.</param>
        /// 
        /// <returns>Returns a  ModifyPrivateDnsNameOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyPrivateDnsNameOptions">REST API Reference for ModifyPrivateDnsNameOptions Operation</seealso>
        public virtual ModifyPrivateDnsNameOptionsResponse EndModifyPrivateDnsNameOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyPrivateDnsNameOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyReservedInstances

        /// <summary>
        /// Modifies the configuration of your Reserved Instances, such as the Availability Zone,
        /// instance count, or instance type. The Reserved Instances to be modified must be identical,
        /// except for Availability Zone, network platform, and instance type.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-modifying.html">Modifying
        /// Reserved Instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyReservedInstances service method.</param>
        /// 
        /// <returns>The response from the ModifyReservedInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyReservedInstances">REST API Reference for ModifyReservedInstances Operation</seealso>
        public virtual ModifyReservedInstancesResponse ModifyReservedInstances(ModifyReservedInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyReservedInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyReservedInstancesResponseUnmarshaller.Instance;

            return Invoke<ModifyReservedInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyReservedInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyReservedInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyReservedInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyReservedInstances">REST API Reference for ModifyReservedInstances Operation</seealso>
        public virtual IAsyncResult BeginModifyReservedInstances(ModifyReservedInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyReservedInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyReservedInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyReservedInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyReservedInstances.</param>
        /// 
        /// <returns>Returns a  ModifyReservedInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyReservedInstances">REST API Reference for ModifyReservedInstances Operation</seealso>
        public virtual ModifyReservedInstancesResponse EndModifyReservedInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyReservedInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifySecurityGroupRules

        /// <summary>
        /// Modifies the rules of a security group.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifySecurityGroupRules service method.</param>
        /// 
        /// <returns>The response from the ModifySecurityGroupRules service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySecurityGroupRules">REST API Reference for ModifySecurityGroupRules Operation</seealso>
        public virtual ModifySecurityGroupRulesResponse ModifySecurityGroupRules(ModifySecurityGroupRulesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySecurityGroupRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySecurityGroupRulesResponseUnmarshaller.Instance;

            return Invoke<ModifySecurityGroupRulesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifySecurityGroupRules operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifySecurityGroupRules operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifySecurityGroupRules
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySecurityGroupRules">REST API Reference for ModifySecurityGroupRules Operation</seealso>
        public virtual IAsyncResult BeginModifySecurityGroupRules(ModifySecurityGroupRulesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySecurityGroupRulesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySecurityGroupRulesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifySecurityGroupRules operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifySecurityGroupRules.</param>
        /// 
        /// <returns>Returns a  ModifySecurityGroupRulesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySecurityGroupRules">REST API Reference for ModifySecurityGroupRules Operation</seealso>
        public virtual ModifySecurityGroupRulesResponse EndModifySecurityGroupRules(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifySecurityGroupRulesResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifySnapshotAttribute

        /// <summary>
        /// Adds or removes permission settings for the specified snapshot. You may add or remove
        /// specified Amazon Web Services account IDs from a snapshot's list of create volume
        /// permissions, but you cannot do both in a single operation. If you need to both add
        /// and remove account IDs for a snapshot, you must use multiple operations. You can make
        /// up to 500 modifications to a snapshot in a single operation.
        /// 
        ///  
        /// <para>
        /// Encrypted snapshots and snapshots with Amazon Web Services Marketplace product codes
        /// cannot be made public. Snapshots encrypted with your default KMS key cannot be shared
        /// with other accounts.
        /// </para>
        ///  
        /// <para>
        /// For more information about modifying snapshot permissions, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modifying-snapshot-permissions.html">Share
        /// a snapshot</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifySnapshotAttribute service method.</param>
        /// 
        /// <returns>The response from the ModifySnapshotAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySnapshotAttribute">REST API Reference for ModifySnapshotAttribute Operation</seealso>
        public virtual ModifySnapshotAttributeResponse ModifySnapshotAttribute(ModifySnapshotAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySnapshotAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySnapshotAttributeResponseUnmarshaller.Instance;

            return Invoke<ModifySnapshotAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifySnapshotAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifySnapshotAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifySnapshotAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySnapshotAttribute">REST API Reference for ModifySnapshotAttribute Operation</seealso>
        public virtual IAsyncResult BeginModifySnapshotAttribute(ModifySnapshotAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySnapshotAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySnapshotAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifySnapshotAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifySnapshotAttribute.</param>
        /// 
        /// <returns>Returns a  ModifySnapshotAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySnapshotAttribute">REST API Reference for ModifySnapshotAttribute Operation</seealso>
        public virtual ModifySnapshotAttributeResponse EndModifySnapshotAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifySnapshotAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifySnapshotTier

        /// <summary>
        /// Archives an Amazon EBS snapshot. When you archive a snapshot, it is converted to a
        /// full snapshot that includes all of the blocks of data that were written to the volume
        /// at the time the snapshot was created, and moved from the standard tier to the archive
        /// tier. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/snapshot-archive.html">Archive
        /// Amazon EBS snapshots</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifySnapshotTier service method.</param>
        /// 
        /// <returns>The response from the ModifySnapshotTier service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySnapshotTier">REST API Reference for ModifySnapshotTier Operation</seealso>
        public virtual ModifySnapshotTierResponse ModifySnapshotTier(ModifySnapshotTierRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySnapshotTierRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySnapshotTierResponseUnmarshaller.Instance;

            return Invoke<ModifySnapshotTierResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifySnapshotTier operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifySnapshotTier operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifySnapshotTier
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySnapshotTier">REST API Reference for ModifySnapshotTier Operation</seealso>
        public virtual IAsyncResult BeginModifySnapshotTier(ModifySnapshotTierRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySnapshotTierRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySnapshotTierResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifySnapshotTier operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifySnapshotTier.</param>
        /// 
        /// <returns>Returns a  ModifySnapshotTierResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySnapshotTier">REST API Reference for ModifySnapshotTier Operation</seealso>
        public virtual ModifySnapshotTierResponse EndModifySnapshotTier(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifySnapshotTierResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifySpotFleetRequest

        /// <summary>
        /// Modifies the specified Spot Fleet request.
        /// 
        ///  
        /// <para>
        /// You can only modify a Spot Fleet request of type <code>maintain</code>.
        /// </para>
        ///  
        /// <para>
        /// While the Spot Fleet request is being modified, it is in the <code>modifying</code>
        /// state.
        /// </para>
        ///  
        /// <para>
        /// To scale up your Spot Fleet, increase its target capacity. The Spot Fleet launches
        /// the additional Spot Instances according to the allocation strategy for the Spot Fleet
        /// request. If the allocation strategy is <code>lowestPrice</code>, the Spot Fleet launches
        /// instances using the Spot Instance pool with the lowest price. If the allocation strategy
        /// is <code>diversified</code>, the Spot Fleet distributes the instances across the Spot
        /// Instance pools. If the allocation strategy is <code>capacityOptimized</code>, Spot
        /// Fleet launches instances from Spot Instance pools with optimal capacity for the number
        /// of instances that are launching.
        /// </para>
        ///  
        /// <para>
        /// To scale down your Spot Fleet, decrease its target capacity. First, the Spot Fleet
        /// cancels any open requests that exceed the new target capacity. You can request that
        /// the Spot Fleet terminate Spot Instances until the size of the fleet no longer exceeds
        /// the new target capacity. If the allocation strategy is <code>lowestPrice</code>, the
        /// Spot Fleet terminates the instances with the highest price per unit. If the allocation
        /// strategy is <code>capacityOptimized</code>, the Spot Fleet terminates the instances
        /// in the Spot Instance pools that have the least available Spot Instance capacity. If
        /// the allocation strategy is <code>diversified</code>, the Spot Fleet terminates instances
        /// across the Spot Instance pools. Alternatively, you can request that the Spot Fleet
        /// keep the fleet at its current size, but not replace any Spot Instances that are interrupted
        /// or that you terminate manually.
        /// </para>
        ///  
        /// <para>
        /// If you are finished with your Spot Fleet for now, but will use it again later, you
        /// can set the target capacity to 0.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifySpotFleetRequest service method.</param>
        /// 
        /// <returns>The response from the ModifySpotFleetRequest service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySpotFleetRequest">REST API Reference for ModifySpotFleetRequest Operation</seealso>
        public virtual ModifySpotFleetRequestResponse ModifySpotFleetRequest(ModifySpotFleetRequestRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySpotFleetRequestRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySpotFleetRequestResponseUnmarshaller.Instance;

            return Invoke<ModifySpotFleetRequestResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifySpotFleetRequest operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifySpotFleetRequest operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifySpotFleetRequest
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySpotFleetRequest">REST API Reference for ModifySpotFleetRequest Operation</seealso>
        public virtual IAsyncResult BeginModifySpotFleetRequest(ModifySpotFleetRequestRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySpotFleetRequestRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySpotFleetRequestResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifySpotFleetRequest operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifySpotFleetRequest.</param>
        /// 
        /// <returns>Returns a  ModifySpotFleetRequestResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySpotFleetRequest">REST API Reference for ModifySpotFleetRequest Operation</seealso>
        public virtual ModifySpotFleetRequestResponse EndModifySpotFleetRequest(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifySpotFleetRequestResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifySubnetAttribute

        /// <summary>
        /// Modifies a subnet attribute. You can only modify one attribute at a time.
        /// 
        ///  
        /// <para>
        /// Use this action to modify subnets on Amazon Web Services Outposts.
        /// </para>
        ///  <ul> <li> 
        /// <para>
        /// To modify a subnet on an Outpost rack, set both <code>MapCustomerOwnedIpOnLaunch</code>
        /// and <code>CustomerOwnedIpv4Pool</code>. These two parameters act as a single attribute.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// To modify a subnet on an Outpost server, set either <code>EnableLniAtDeviceIndex</code>
        /// or <code>DisableLniAtDeviceIndex</code>.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// For more information about Amazon Web Services Outposts, see the following:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        ///  <a href="https://docs.aws.amazon.com/outposts/latest/userguide/how-servers-work.html">Outpost
        /// servers</a> 
        /// </para>
        ///  </li> <li> 
        /// <para>
        ///  <a href="https://docs.aws.amazon.com/outposts/latest/userguide/how-racks-work.html">Outpost
        /// racks</a> 
        /// </para>
        ///  </li> </ul>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifySubnetAttribute service method.</param>
        /// 
        /// <returns>The response from the ModifySubnetAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySubnetAttribute">REST API Reference for ModifySubnetAttribute Operation</seealso>
        public virtual ModifySubnetAttributeResponse ModifySubnetAttribute(ModifySubnetAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySubnetAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySubnetAttributeResponseUnmarshaller.Instance;

            return Invoke<ModifySubnetAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifySubnetAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifySubnetAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifySubnetAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySubnetAttribute">REST API Reference for ModifySubnetAttribute Operation</seealso>
        public virtual IAsyncResult BeginModifySubnetAttribute(ModifySubnetAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifySubnetAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifySubnetAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifySubnetAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifySubnetAttribute.</param>
        /// 
        /// <returns>Returns a  ModifySubnetAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifySubnetAttribute">REST API Reference for ModifySubnetAttribute Operation</seealso>
        public virtual ModifySubnetAttributeResponse EndModifySubnetAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifySubnetAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyTrafficMirrorFilterNetworkServices

        /// <summary>
        /// Allows or restricts mirroring network services.
        /// 
        ///  
        /// <para>
        ///  By default, Amazon DNS network services are not eligible for Traffic Mirror. Use
        /// <code>AddNetworkServices</code> to add network services to a Traffic Mirror filter.
        /// When a network service is added to the Traffic Mirror filter, all traffic related
        /// to that network service will be mirrored. When you no longer want to mirror network
        /// services, use <code>RemoveNetworkServices</code> to remove the network services from
        /// the Traffic Mirror filter. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyTrafficMirrorFilterNetworkServices service method.</param>
        /// 
        /// <returns>The response from the ModifyTrafficMirrorFilterNetworkServices service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorFilterNetworkServices">REST API Reference for ModifyTrafficMirrorFilterNetworkServices Operation</seealso>
        public virtual ModifyTrafficMirrorFilterNetworkServicesResponse ModifyTrafficMirrorFilterNetworkServices(ModifyTrafficMirrorFilterNetworkServicesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTrafficMirrorFilterNetworkServicesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTrafficMirrorFilterNetworkServicesResponseUnmarshaller.Instance;

            return Invoke<ModifyTrafficMirrorFilterNetworkServicesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyTrafficMirrorFilterNetworkServices operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyTrafficMirrorFilterNetworkServices operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyTrafficMirrorFilterNetworkServices
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorFilterNetworkServices">REST API Reference for ModifyTrafficMirrorFilterNetworkServices Operation</seealso>
        public virtual IAsyncResult BeginModifyTrafficMirrorFilterNetworkServices(ModifyTrafficMirrorFilterNetworkServicesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTrafficMirrorFilterNetworkServicesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTrafficMirrorFilterNetworkServicesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyTrafficMirrorFilterNetworkServices operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyTrafficMirrorFilterNetworkServices.</param>
        /// 
        /// <returns>Returns a  ModifyTrafficMirrorFilterNetworkServicesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorFilterNetworkServices">REST API Reference for ModifyTrafficMirrorFilterNetworkServices Operation</seealso>
        public virtual ModifyTrafficMirrorFilterNetworkServicesResponse EndModifyTrafficMirrorFilterNetworkServices(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyTrafficMirrorFilterNetworkServicesResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyTrafficMirrorFilterRule

        /// <summary>
        /// Modifies the specified Traffic Mirror rule.
        /// 
        ///  
        /// <para>
        ///  <code>DestinationCidrBlock</code> and <code>SourceCidrBlock</code> must both be an
        /// IPv4 range or an IPv6 range.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyTrafficMirrorFilterRule service method.</param>
        /// 
        /// <returns>The response from the ModifyTrafficMirrorFilterRule service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorFilterRule">REST API Reference for ModifyTrafficMirrorFilterRule Operation</seealso>
        public virtual ModifyTrafficMirrorFilterRuleResponse ModifyTrafficMirrorFilterRule(ModifyTrafficMirrorFilterRuleRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTrafficMirrorFilterRuleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTrafficMirrorFilterRuleResponseUnmarshaller.Instance;

            return Invoke<ModifyTrafficMirrorFilterRuleResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyTrafficMirrorFilterRule operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyTrafficMirrorFilterRule operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyTrafficMirrorFilterRule
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorFilterRule">REST API Reference for ModifyTrafficMirrorFilterRule Operation</seealso>
        public virtual IAsyncResult BeginModifyTrafficMirrorFilterRule(ModifyTrafficMirrorFilterRuleRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTrafficMirrorFilterRuleRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTrafficMirrorFilterRuleResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyTrafficMirrorFilterRule operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyTrafficMirrorFilterRule.</param>
        /// 
        /// <returns>Returns a  ModifyTrafficMirrorFilterRuleResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorFilterRule">REST API Reference for ModifyTrafficMirrorFilterRule Operation</seealso>
        public virtual ModifyTrafficMirrorFilterRuleResponse EndModifyTrafficMirrorFilterRule(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyTrafficMirrorFilterRuleResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyTrafficMirrorSession

        /// <summary>
        /// Modifies a Traffic Mirror session.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyTrafficMirrorSession service method.</param>
        /// 
        /// <returns>The response from the ModifyTrafficMirrorSession service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorSession">REST API Reference for ModifyTrafficMirrorSession Operation</seealso>
        public virtual ModifyTrafficMirrorSessionResponse ModifyTrafficMirrorSession(ModifyTrafficMirrorSessionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTrafficMirrorSessionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTrafficMirrorSessionResponseUnmarshaller.Instance;

            return Invoke<ModifyTrafficMirrorSessionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyTrafficMirrorSession operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyTrafficMirrorSession operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyTrafficMirrorSession
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorSession">REST API Reference for ModifyTrafficMirrorSession Operation</seealso>
        public virtual IAsyncResult BeginModifyTrafficMirrorSession(ModifyTrafficMirrorSessionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTrafficMirrorSessionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTrafficMirrorSessionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyTrafficMirrorSession operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyTrafficMirrorSession.</param>
        /// 
        /// <returns>Returns a  ModifyTrafficMirrorSessionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTrafficMirrorSession">REST API Reference for ModifyTrafficMirrorSession Operation</seealso>
        public virtual ModifyTrafficMirrorSessionResponse EndModifyTrafficMirrorSession(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyTrafficMirrorSessionResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyTransitGateway

        /// <summary>
        /// Modifies the specified transit gateway. When you modify a transit gateway, the modified
        /// options are applied to new transit gateway attachments only. Your existing transit
        /// gateway attachments are not modified.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyTransitGateway service method.</param>
        /// 
        /// <returns>The response from the ModifyTransitGateway service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGateway">REST API Reference for ModifyTransitGateway Operation</seealso>
        public virtual ModifyTransitGatewayResponse ModifyTransitGateway(ModifyTransitGatewayRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTransitGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTransitGatewayResponseUnmarshaller.Instance;

            return Invoke<ModifyTransitGatewayResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyTransitGateway operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyTransitGateway operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyTransitGateway
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGateway">REST API Reference for ModifyTransitGateway Operation</seealso>
        public virtual IAsyncResult BeginModifyTransitGateway(ModifyTransitGatewayRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTransitGatewayRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTransitGatewayResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyTransitGateway operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyTransitGateway.</param>
        /// 
        /// <returns>Returns a  ModifyTransitGatewayResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGateway">REST API Reference for ModifyTransitGateway Operation</seealso>
        public virtual ModifyTransitGatewayResponse EndModifyTransitGateway(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyTransitGatewayResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyTransitGatewayPrefixListReference

        /// <summary>
        /// Modifies a reference (route) to a prefix list in a specified transit gateway route
        /// table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyTransitGatewayPrefixListReference service method.</param>
        /// 
        /// <returns>The response from the ModifyTransitGatewayPrefixListReference service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGatewayPrefixListReference">REST API Reference for ModifyTransitGatewayPrefixListReference Operation</seealso>
        public virtual ModifyTransitGatewayPrefixListReferenceResponse ModifyTransitGatewayPrefixListReference(ModifyTransitGatewayPrefixListReferenceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTransitGatewayPrefixListReferenceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTransitGatewayPrefixListReferenceResponseUnmarshaller.Instance;

            return Invoke<ModifyTransitGatewayPrefixListReferenceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyTransitGatewayPrefixListReference operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyTransitGatewayPrefixListReference operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyTransitGatewayPrefixListReference
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGatewayPrefixListReference">REST API Reference for ModifyTransitGatewayPrefixListReference Operation</seealso>
        public virtual IAsyncResult BeginModifyTransitGatewayPrefixListReference(ModifyTransitGatewayPrefixListReferenceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTransitGatewayPrefixListReferenceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTransitGatewayPrefixListReferenceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyTransitGatewayPrefixListReference operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyTransitGatewayPrefixListReference.</param>
        /// 
        /// <returns>Returns a  ModifyTransitGatewayPrefixListReferenceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGatewayPrefixListReference">REST API Reference for ModifyTransitGatewayPrefixListReference Operation</seealso>
        public virtual ModifyTransitGatewayPrefixListReferenceResponse EndModifyTransitGatewayPrefixListReference(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyTransitGatewayPrefixListReferenceResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyTransitGatewayVpcAttachment

        /// <summary>
        /// Modifies the specified VPC attachment.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyTransitGatewayVpcAttachment service method.</param>
        /// 
        /// <returns>The response from the ModifyTransitGatewayVpcAttachment service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGatewayVpcAttachment">REST API Reference for ModifyTransitGatewayVpcAttachment Operation</seealso>
        public virtual ModifyTransitGatewayVpcAttachmentResponse ModifyTransitGatewayVpcAttachment(ModifyTransitGatewayVpcAttachmentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return Invoke<ModifyTransitGatewayVpcAttachmentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyTransitGatewayVpcAttachment operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyTransitGatewayVpcAttachment
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGatewayVpcAttachment">REST API Reference for ModifyTransitGatewayVpcAttachment Operation</seealso>
        public virtual IAsyncResult BeginModifyTransitGatewayVpcAttachment(ModifyTransitGatewayVpcAttachmentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyTransitGatewayVpcAttachment.</param>
        /// 
        /// <returns>Returns a  ModifyTransitGatewayVpcAttachmentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyTransitGatewayVpcAttachment">REST API Reference for ModifyTransitGatewayVpcAttachment Operation</seealso>
        public virtual ModifyTransitGatewayVpcAttachmentResponse EndModifyTransitGatewayVpcAttachment(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyTransitGatewayVpcAttachmentResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVerifiedAccessEndpoint

        /// <summary>
        /// Modifies the configuration of the specified Amazon Web Services Verified Access endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessEndpoint service method.</param>
        /// 
        /// <returns>The response from the ModifyVerifiedAccessEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessEndpoint">REST API Reference for ModifyVerifiedAccessEndpoint Operation</seealso>
        public virtual ModifyVerifiedAccessEndpointResponse ModifyVerifiedAccessEndpoint(ModifyVerifiedAccessEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessEndpointResponseUnmarshaller.Instance;

            return Invoke<ModifyVerifiedAccessEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVerifiedAccessEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVerifiedAccessEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessEndpoint">REST API Reference for ModifyVerifiedAccessEndpoint Operation</seealso>
        public virtual IAsyncResult BeginModifyVerifiedAccessEndpoint(ModifyVerifiedAccessEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVerifiedAccessEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVerifiedAccessEndpoint.</param>
        /// 
        /// <returns>Returns a  ModifyVerifiedAccessEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessEndpoint">REST API Reference for ModifyVerifiedAccessEndpoint Operation</seealso>
        public virtual ModifyVerifiedAccessEndpointResponse EndModifyVerifiedAccessEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVerifiedAccessEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVerifiedAccessEndpointPolicy

        /// <summary>
        /// Modifies the specified Amazon Web Services Verified Access endpoint policy.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessEndpointPolicy service method.</param>
        /// 
        /// <returns>The response from the ModifyVerifiedAccessEndpointPolicy service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessEndpointPolicy">REST API Reference for ModifyVerifiedAccessEndpointPolicy Operation</seealso>
        public virtual ModifyVerifiedAccessEndpointPolicyResponse ModifyVerifiedAccessEndpointPolicy(ModifyVerifiedAccessEndpointPolicyRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessEndpointPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessEndpointPolicyResponseUnmarshaller.Instance;

            return Invoke<ModifyVerifiedAccessEndpointPolicyResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVerifiedAccessEndpointPolicy operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessEndpointPolicy operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVerifiedAccessEndpointPolicy
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessEndpointPolicy">REST API Reference for ModifyVerifiedAccessEndpointPolicy Operation</seealso>
        public virtual IAsyncResult BeginModifyVerifiedAccessEndpointPolicy(ModifyVerifiedAccessEndpointPolicyRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessEndpointPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessEndpointPolicyResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVerifiedAccessEndpointPolicy operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVerifiedAccessEndpointPolicy.</param>
        /// 
        /// <returns>Returns a  ModifyVerifiedAccessEndpointPolicyResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessEndpointPolicy">REST API Reference for ModifyVerifiedAccessEndpointPolicy Operation</seealso>
        public virtual ModifyVerifiedAccessEndpointPolicyResponse EndModifyVerifiedAccessEndpointPolicy(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVerifiedAccessEndpointPolicyResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVerifiedAccessGroup

        /// <summary>
        /// Modifies the specified Amazon Web Services Verified Access group configuration.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessGroup service method.</param>
        /// 
        /// <returns>The response from the ModifyVerifiedAccessGroup service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessGroup">REST API Reference for ModifyVerifiedAccessGroup Operation</seealso>
        public virtual ModifyVerifiedAccessGroupResponse ModifyVerifiedAccessGroup(ModifyVerifiedAccessGroupRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessGroupResponseUnmarshaller.Instance;

            return Invoke<ModifyVerifiedAccessGroupResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVerifiedAccessGroup operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessGroup operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVerifiedAccessGroup
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessGroup">REST API Reference for ModifyVerifiedAccessGroup Operation</seealso>
        public virtual IAsyncResult BeginModifyVerifiedAccessGroup(ModifyVerifiedAccessGroupRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessGroupRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessGroupResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVerifiedAccessGroup operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVerifiedAccessGroup.</param>
        /// 
        /// <returns>Returns a  ModifyVerifiedAccessGroupResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessGroup">REST API Reference for ModifyVerifiedAccessGroup Operation</seealso>
        public virtual ModifyVerifiedAccessGroupResponse EndModifyVerifiedAccessGroup(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVerifiedAccessGroupResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVerifiedAccessGroupPolicy

        /// <summary>
        /// Modifies the specified Amazon Web Services Verified Access group policy.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessGroupPolicy service method.</param>
        /// 
        /// <returns>The response from the ModifyVerifiedAccessGroupPolicy service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessGroupPolicy">REST API Reference for ModifyVerifiedAccessGroupPolicy Operation</seealso>
        public virtual ModifyVerifiedAccessGroupPolicyResponse ModifyVerifiedAccessGroupPolicy(ModifyVerifiedAccessGroupPolicyRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessGroupPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessGroupPolicyResponseUnmarshaller.Instance;

            return Invoke<ModifyVerifiedAccessGroupPolicyResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVerifiedAccessGroupPolicy operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessGroupPolicy operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVerifiedAccessGroupPolicy
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessGroupPolicy">REST API Reference for ModifyVerifiedAccessGroupPolicy Operation</seealso>
        public virtual IAsyncResult BeginModifyVerifiedAccessGroupPolicy(ModifyVerifiedAccessGroupPolicyRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessGroupPolicyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessGroupPolicyResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVerifiedAccessGroupPolicy operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVerifiedAccessGroupPolicy.</param>
        /// 
        /// <returns>Returns a  ModifyVerifiedAccessGroupPolicyResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessGroupPolicy">REST API Reference for ModifyVerifiedAccessGroupPolicy Operation</seealso>
        public virtual ModifyVerifiedAccessGroupPolicyResponse EndModifyVerifiedAccessGroupPolicy(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVerifiedAccessGroupPolicyResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVerifiedAccessInstance

        /// <summary>
        /// Modifies the configuration of the specified Amazon Web Services Verified Access instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessInstance service method.</param>
        /// 
        /// <returns>The response from the ModifyVerifiedAccessInstance service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessInstance">REST API Reference for ModifyVerifiedAccessInstance Operation</seealso>
        public virtual ModifyVerifiedAccessInstanceResponse ModifyVerifiedAccessInstance(ModifyVerifiedAccessInstanceRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessInstanceResponseUnmarshaller.Instance;

            return Invoke<ModifyVerifiedAccessInstanceResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVerifiedAccessInstance operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessInstance operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVerifiedAccessInstance
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessInstance">REST API Reference for ModifyVerifiedAccessInstance Operation</seealso>
        public virtual IAsyncResult BeginModifyVerifiedAccessInstance(ModifyVerifiedAccessInstanceRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessInstanceRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessInstanceResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVerifiedAccessInstance operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVerifiedAccessInstance.</param>
        /// 
        /// <returns>Returns a  ModifyVerifiedAccessInstanceResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessInstance">REST API Reference for ModifyVerifiedAccessInstance Operation</seealso>
        public virtual ModifyVerifiedAccessInstanceResponse EndModifyVerifiedAccessInstance(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVerifiedAccessInstanceResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVerifiedAccessInstanceLoggingConfiguration

        /// <summary>
        /// Modifies the logging configuration for the specified Amazon Web Services Verified
        /// Access instance.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessInstanceLoggingConfiguration service method.</param>
        /// 
        /// <returns>The response from the ModifyVerifiedAccessInstanceLoggingConfiguration service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessInstanceLoggingConfiguration">REST API Reference for ModifyVerifiedAccessInstanceLoggingConfiguration Operation</seealso>
        public virtual ModifyVerifiedAccessInstanceLoggingConfigurationResponse ModifyVerifiedAccessInstanceLoggingConfiguration(ModifyVerifiedAccessInstanceLoggingConfigurationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessInstanceLoggingConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessInstanceLoggingConfigurationResponseUnmarshaller.Instance;

            return Invoke<ModifyVerifiedAccessInstanceLoggingConfigurationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVerifiedAccessInstanceLoggingConfiguration operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessInstanceLoggingConfiguration operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVerifiedAccessInstanceLoggingConfiguration
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessInstanceLoggingConfiguration">REST API Reference for ModifyVerifiedAccessInstanceLoggingConfiguration Operation</seealso>
        public virtual IAsyncResult BeginModifyVerifiedAccessInstanceLoggingConfiguration(ModifyVerifiedAccessInstanceLoggingConfigurationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessInstanceLoggingConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessInstanceLoggingConfigurationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVerifiedAccessInstanceLoggingConfiguration operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVerifiedAccessInstanceLoggingConfiguration.</param>
        /// 
        /// <returns>Returns a  ModifyVerifiedAccessInstanceLoggingConfigurationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessInstanceLoggingConfiguration">REST API Reference for ModifyVerifiedAccessInstanceLoggingConfiguration Operation</seealso>
        public virtual ModifyVerifiedAccessInstanceLoggingConfigurationResponse EndModifyVerifiedAccessInstanceLoggingConfiguration(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVerifiedAccessInstanceLoggingConfigurationResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVerifiedAccessTrustProvider

        /// <summary>
        /// Modifies the configuration of the specified Amazon Web Services Verified Access trust
        /// provider.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessTrustProvider service method.</param>
        /// 
        /// <returns>The response from the ModifyVerifiedAccessTrustProvider service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessTrustProvider">REST API Reference for ModifyVerifiedAccessTrustProvider Operation</seealso>
        public virtual ModifyVerifiedAccessTrustProviderResponse ModifyVerifiedAccessTrustProvider(ModifyVerifiedAccessTrustProviderRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return Invoke<ModifyVerifiedAccessTrustProviderResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVerifiedAccessTrustProvider operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVerifiedAccessTrustProvider
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessTrustProvider">REST API Reference for ModifyVerifiedAccessTrustProvider Operation</seealso>
        public virtual IAsyncResult BeginModifyVerifiedAccessTrustProvider(ModifyVerifiedAccessTrustProviderRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVerifiedAccessTrustProviderRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVerifiedAccessTrustProviderResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVerifiedAccessTrustProvider operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVerifiedAccessTrustProvider.</param>
        /// 
        /// <returns>Returns a  ModifyVerifiedAccessTrustProviderResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVerifiedAccessTrustProvider">REST API Reference for ModifyVerifiedAccessTrustProvider Operation</seealso>
        public virtual ModifyVerifiedAccessTrustProviderResponse EndModifyVerifiedAccessTrustProvider(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVerifiedAccessTrustProviderResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVolume

        /// <summary>
        /// You can modify several parameters of an existing EBS volume, including volume size,
        /// volume type, and IOPS capacity. If your EBS volume is attached to a current-generation
        /// EC2 instance type, you might be able to apply these changes without stopping the instance
        /// or detaching the volume from it. For more information about modifying EBS volumes,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modify-volume.html">Amazon
        /// EBS Elastic Volumes</a> (Linux instances) or <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ebs-modify-volume.html">Amazon
        /// EBS Elastic Volumes</a> (Windows instances).
        /// 
        ///  
        /// <para>
        /// When you complete a resize operation on your volume, you need to extend the volume's
        /// file-system size to take advantage of the new storage capacity. For more information,
        /// see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-expand-volume.html#recognize-expanded-volume-linux">Extend
        /// a Linux file system</a> or <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/ebs-expand-volume.html#recognize-expanded-volume-windows">Extend
        /// a Windows file system</a>.
        /// </para>
        ///  
        /// <para>
        ///  You can use CloudWatch Events to check the status of a modification to an EBS volume.
        /// For information about CloudWatch Events, see the <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/">Amazon
        /// CloudWatch Events User Guide</a>. You can also track the status of a modification
        /// using <a>DescribeVolumesModifications</a>. For information about tracking status changes
        /// using either method, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-volume-modifications.html">Monitor
        /// the progress of volume modifications</a>.
        /// </para>
        ///  
        /// <para>
        /// With previous-generation instance types, resizing an EBS volume might require detaching
        /// and reattaching the volume or stopping and restarting the instance.
        /// </para>
        ///  
        /// <para>
        /// After modifying a volume, you must wait at least six hours and ensure that the volume
        /// is in the <code>in-use</code> or <code>available</code> state before you can modify
        /// the same volume. This is sometimes referred to as a cooldown period.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVolume service method.</param>
        /// 
        /// <returns>The response from the ModifyVolume service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVolume">REST API Reference for ModifyVolume Operation</seealso>
        public virtual ModifyVolumeResponse ModifyVolume(ModifyVolumeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVolumeResponseUnmarshaller.Instance;

            return Invoke<ModifyVolumeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVolume operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVolume operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVolume
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVolume">REST API Reference for ModifyVolume Operation</seealso>
        public virtual IAsyncResult BeginModifyVolume(ModifyVolumeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVolumeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVolumeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVolume operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVolume.</param>
        /// 
        /// <returns>Returns a  ModifyVolumeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVolume">REST API Reference for ModifyVolume Operation</seealso>
        public virtual ModifyVolumeResponse EndModifyVolume(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVolumeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVolumeAttribute

        /// <summary>
        /// Modifies a volume attribute.
        /// 
        ///  
        /// <para>
        /// By default, all I/O operations for the volume are suspended when the data on the volume
        /// is determined to be potentially inconsistent, to prevent undetectable, latent data
        /// corruption. The I/O access to the volume can be resumed by first enabling I/O access
        /// and then checking the data consistency on your volume.
        /// </para>
        ///  
        /// <para>
        /// You can change the default behavior to resume I/O operations. We recommend that you
        /// change this only for boot volumes or for volumes that are stateless or disposable.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVolumeAttribute service method.</param>
        /// 
        /// <returns>The response from the ModifyVolumeAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVolumeAttribute">REST API Reference for ModifyVolumeAttribute Operation</seealso>
        public virtual ModifyVolumeAttributeResponse ModifyVolumeAttribute(ModifyVolumeAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVolumeAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVolumeAttributeResponseUnmarshaller.Instance;

            return Invoke<ModifyVolumeAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVolumeAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVolumeAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVolumeAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVolumeAttribute">REST API Reference for ModifyVolumeAttribute Operation</seealso>
        public virtual IAsyncResult BeginModifyVolumeAttribute(ModifyVolumeAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVolumeAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVolumeAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVolumeAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVolumeAttribute.</param>
        /// 
        /// <returns>Returns a  ModifyVolumeAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVolumeAttribute">REST API Reference for ModifyVolumeAttribute Operation</seealso>
        public virtual ModifyVolumeAttributeResponse EndModifyVolumeAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVolumeAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpcAttribute

        /// <summary>
        /// Modifies the specified attribute of the specified VPC.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcAttribute service method.</param>
        /// 
        /// <returns>The response from the ModifyVpcAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcAttribute">REST API Reference for ModifyVpcAttribute Operation</seealso>
        public virtual ModifyVpcAttributeResponse ModifyVpcAttribute(ModifyVpcAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcAttributeResponseUnmarshaller.Instance;

            return Invoke<ModifyVpcAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpcAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpcAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcAttribute">REST API Reference for ModifyVpcAttribute Operation</seealso>
        public virtual IAsyncResult BeginModifyVpcAttribute(ModifyVpcAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpcAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpcAttribute.</param>
        /// 
        /// <returns>Returns a  ModifyVpcAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcAttribute">REST API Reference for ModifyVpcAttribute Operation</seealso>
        public virtual ModifyVpcAttributeResponse EndModifyVpcAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpcAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpcEndpoint

        /// <summary>
        /// Modifies attributes of a specified VPC endpoint. The attributes that you can modify
        /// depend on the type of VPC endpoint (interface, gateway, or Gateway Load Balancer).
        /// For more information, see the <a href="https://docs.aws.amazon.com/vpc/latest/privatelink/">Amazon
        /// Web Services PrivateLink Guide</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpoint service method.</param>
        /// 
        /// <returns>The response from the ModifyVpcEndpoint service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpoint">REST API Reference for ModifyVpcEndpoint Operation</seealso>
        public virtual ModifyVpcEndpointResponse ModifyVpcEndpoint(ModifyVpcEndpointRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointResponseUnmarshaller.Instance;

            return Invoke<ModifyVpcEndpointResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpcEndpoint operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpoint operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpcEndpoint
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpoint">REST API Reference for ModifyVpcEndpoint Operation</seealso>
        public virtual IAsyncResult BeginModifyVpcEndpoint(ModifyVpcEndpointRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpcEndpoint operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpcEndpoint.</param>
        /// 
        /// <returns>Returns a  ModifyVpcEndpointResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpoint">REST API Reference for ModifyVpcEndpoint Operation</seealso>
        public virtual ModifyVpcEndpointResponse EndModifyVpcEndpoint(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpcEndpointResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpcEndpointConnectionNotification

        /// <summary>
        /// Modifies a connection notification for VPC endpoint or VPC endpoint service. You can
        /// change the SNS topic for the notification, or the events for which to be notified.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpointConnectionNotification service method.</param>
        /// 
        /// <returns>The response from the ModifyVpcEndpointConnectionNotification service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointConnectionNotification">REST API Reference for ModifyVpcEndpointConnectionNotification Operation</seealso>
        public virtual ModifyVpcEndpointConnectionNotificationResponse ModifyVpcEndpointConnectionNotification(ModifyVpcEndpointConnectionNotificationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointConnectionNotificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointConnectionNotificationResponseUnmarshaller.Instance;

            return Invoke<ModifyVpcEndpointConnectionNotificationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpcEndpointConnectionNotification operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpointConnectionNotification operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpcEndpointConnectionNotification
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointConnectionNotification">REST API Reference for ModifyVpcEndpointConnectionNotification Operation</seealso>
        public virtual IAsyncResult BeginModifyVpcEndpointConnectionNotification(ModifyVpcEndpointConnectionNotificationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointConnectionNotificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointConnectionNotificationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpcEndpointConnectionNotification operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpcEndpointConnectionNotification.</param>
        /// 
        /// <returns>Returns a  ModifyVpcEndpointConnectionNotificationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointConnectionNotification">REST API Reference for ModifyVpcEndpointConnectionNotification Operation</seealso>
        public virtual ModifyVpcEndpointConnectionNotificationResponse EndModifyVpcEndpointConnectionNotification(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpcEndpointConnectionNotificationResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpcEndpointServiceConfiguration

        /// <summary>
        /// Modifies the attributes of your VPC endpoint service configuration. You can change
        /// the Network Load Balancers or Gateway Load Balancers for your service, and you can
        /// specify whether acceptance is required for requests to connect to your endpoint service
        /// through an interface VPC endpoint.
        /// 
        ///  
        /// <para>
        /// If you set or modify the private DNS name, you must prove that you own the private
        /// DNS domain name.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpointServiceConfiguration service method.</param>
        /// 
        /// <returns>The response from the ModifyVpcEndpointServiceConfiguration service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServiceConfiguration">REST API Reference for ModifyVpcEndpointServiceConfiguration Operation</seealso>
        public virtual ModifyVpcEndpointServiceConfigurationResponse ModifyVpcEndpointServiceConfiguration(ModifyVpcEndpointServiceConfigurationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointServiceConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointServiceConfigurationResponseUnmarshaller.Instance;

            return Invoke<ModifyVpcEndpointServiceConfigurationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpcEndpointServiceConfiguration operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpointServiceConfiguration operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpcEndpointServiceConfiguration
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServiceConfiguration">REST API Reference for ModifyVpcEndpointServiceConfiguration Operation</seealso>
        public virtual IAsyncResult BeginModifyVpcEndpointServiceConfiguration(ModifyVpcEndpointServiceConfigurationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointServiceConfigurationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointServiceConfigurationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpcEndpointServiceConfiguration operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpcEndpointServiceConfiguration.</param>
        /// 
        /// <returns>Returns a  ModifyVpcEndpointServiceConfigurationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServiceConfiguration">REST API Reference for ModifyVpcEndpointServiceConfiguration Operation</seealso>
        public virtual ModifyVpcEndpointServiceConfigurationResponse EndModifyVpcEndpointServiceConfiguration(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpcEndpointServiceConfigurationResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpcEndpointServicePayerResponsibility

        /// <summary>
        /// Modifies the payer responsibility for your VPC endpoint service.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpointServicePayerResponsibility service method.</param>
        /// 
        /// <returns>The response from the ModifyVpcEndpointServicePayerResponsibility service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServicePayerResponsibility">REST API Reference for ModifyVpcEndpointServicePayerResponsibility Operation</seealso>
        public virtual ModifyVpcEndpointServicePayerResponsibilityResponse ModifyVpcEndpointServicePayerResponsibility(ModifyVpcEndpointServicePayerResponsibilityRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointServicePayerResponsibilityRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointServicePayerResponsibilityResponseUnmarshaller.Instance;

            return Invoke<ModifyVpcEndpointServicePayerResponsibilityResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpcEndpointServicePayerResponsibility operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpointServicePayerResponsibility operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpcEndpointServicePayerResponsibility
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServicePayerResponsibility">REST API Reference for ModifyVpcEndpointServicePayerResponsibility Operation</seealso>
        public virtual IAsyncResult BeginModifyVpcEndpointServicePayerResponsibility(ModifyVpcEndpointServicePayerResponsibilityRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointServicePayerResponsibilityRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointServicePayerResponsibilityResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpcEndpointServicePayerResponsibility operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpcEndpointServicePayerResponsibility.</param>
        /// 
        /// <returns>Returns a  ModifyVpcEndpointServicePayerResponsibilityResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServicePayerResponsibility">REST API Reference for ModifyVpcEndpointServicePayerResponsibility Operation</seealso>
        public virtual ModifyVpcEndpointServicePayerResponsibilityResponse EndModifyVpcEndpointServicePayerResponsibility(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpcEndpointServicePayerResponsibilityResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpcEndpointServicePermissions

        /// <summary>
        /// Modifies the permissions for your VPC endpoint service. You can add or remove permissions
        /// for service consumers (Amazon Web Services accounts, users, and IAM roles) to connect
        /// to your endpoint service.
        /// 
        ///  
        /// <para>
        /// If you grant permissions to all principals, the service is public. Any users who know
        /// the name of a public service can send a request to attach an endpoint. If the service
        /// does not require manual approval, attachments are automatically approved.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpointServicePermissions service method.</param>
        /// 
        /// <returns>The response from the ModifyVpcEndpointServicePermissions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServicePermissions">REST API Reference for ModifyVpcEndpointServicePermissions Operation</seealso>
        public virtual ModifyVpcEndpointServicePermissionsResponse ModifyVpcEndpointServicePermissions(ModifyVpcEndpointServicePermissionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointServicePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointServicePermissionsResponseUnmarshaller.Instance;

            return Invoke<ModifyVpcEndpointServicePermissionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpcEndpointServicePermissions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcEndpointServicePermissions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpcEndpointServicePermissions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServicePermissions">REST API Reference for ModifyVpcEndpointServicePermissions Operation</seealso>
        public virtual IAsyncResult BeginModifyVpcEndpointServicePermissions(ModifyVpcEndpointServicePermissionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcEndpointServicePermissionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcEndpointServicePermissionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpcEndpointServicePermissions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpcEndpointServicePermissions.</param>
        /// 
        /// <returns>Returns a  ModifyVpcEndpointServicePermissionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcEndpointServicePermissions">REST API Reference for ModifyVpcEndpointServicePermissions Operation</seealso>
        public virtual ModifyVpcEndpointServicePermissionsResponse EndModifyVpcEndpointServicePermissions(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpcEndpointServicePermissionsResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpcPeeringConnectionOptions

        /// <summary>
        /// Modifies the VPC peering connection options on one side of a VPC peering connection.
        /// 
        ///  
        /// <para>
        /// If the peered VPCs are in the same Amazon Web Services account, you can enable DNS
        /// resolution for queries from the local VPC. This ensures that queries from the local
        /// VPC resolve to private IP addresses in the peer VPC. This option is not available
        /// if the peered VPCs are in different Amazon Web Services accounts or different Regions.
        /// For peered VPCs in different Amazon Web Services accounts, each Amazon Web Services
        /// account owner must initiate a separate request to modify the peering connection options.
        /// For inter-region peering connections, you must use the Region for the requester VPC
        /// to modify the requester VPC peering options and the Region for the accepter VPC to
        /// modify the accepter VPC peering options. To verify which VPCs are the accepter and
        /// the requester for a VPC peering connection, use the <a>DescribeVpcPeeringConnections</a>
        /// command.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcPeeringConnectionOptions service method.</param>
        /// 
        /// <returns>The response from the ModifyVpcPeeringConnectionOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcPeeringConnectionOptions">REST API Reference for ModifyVpcPeeringConnectionOptions Operation</seealso>
        public virtual ModifyVpcPeeringConnectionOptionsResponse ModifyVpcPeeringConnectionOptions(ModifyVpcPeeringConnectionOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcPeeringConnectionOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcPeeringConnectionOptionsResponseUnmarshaller.Instance;

            return Invoke<ModifyVpcPeeringConnectionOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpcPeeringConnectionOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcPeeringConnectionOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpcPeeringConnectionOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcPeeringConnectionOptions">REST API Reference for ModifyVpcPeeringConnectionOptions Operation</seealso>
        public virtual IAsyncResult BeginModifyVpcPeeringConnectionOptions(ModifyVpcPeeringConnectionOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcPeeringConnectionOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcPeeringConnectionOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpcPeeringConnectionOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpcPeeringConnectionOptions.</param>
        /// 
        /// <returns>Returns a  ModifyVpcPeeringConnectionOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcPeeringConnectionOptions">REST API Reference for ModifyVpcPeeringConnectionOptions Operation</seealso>
        public virtual ModifyVpcPeeringConnectionOptionsResponse EndModifyVpcPeeringConnectionOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpcPeeringConnectionOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpcTenancy

        /// <summary>
        /// Modifies the instance tenancy attribute of the specified VPC. You can change the instance
        /// tenancy attribute of a VPC to <code>default</code> only. You cannot change the instance
        /// tenancy attribute to <code>dedicated</code>.
        /// 
        ///  
        /// <para>
        /// After you modify the tenancy of the VPC, any new instances that you launch into the
        /// VPC have a tenancy of <code>default</code>, unless you specify otherwise during launch.
        /// The tenancy of any existing instances in the VPC is not affected.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html">Dedicated
        /// Instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcTenancy service method.</param>
        /// 
        /// <returns>The response from the ModifyVpcTenancy service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcTenancy">REST API Reference for ModifyVpcTenancy Operation</seealso>
        public virtual ModifyVpcTenancyResponse ModifyVpcTenancy(ModifyVpcTenancyRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcTenancyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcTenancyResponseUnmarshaller.Instance;

            return Invoke<ModifyVpcTenancyResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpcTenancy operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpcTenancy operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpcTenancy
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcTenancy">REST API Reference for ModifyVpcTenancy Operation</seealso>
        public virtual IAsyncResult BeginModifyVpcTenancy(ModifyVpcTenancyRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpcTenancyRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpcTenancyResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpcTenancy operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpcTenancy.</param>
        /// 
        /// <returns>Returns a  ModifyVpcTenancyResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpcTenancy">REST API Reference for ModifyVpcTenancy Operation</seealso>
        public virtual ModifyVpcTenancyResponse EndModifyVpcTenancy(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpcTenancyResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpnConnection

        /// <summary>
        /// Modifies the customer gateway or the target gateway of an Amazon Web Services Site-to-Site
        /// VPN connection. To modify the target gateway, the following migration options are
        /// available:
        /// 
        ///  <ul> <li> 
        /// <para>
        /// An existing virtual private gateway to a new virtual private gateway
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// An existing virtual private gateway to a transit gateway
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// An existing transit gateway to a new transit gateway
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// An existing transit gateway to a virtual private gateway
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// Before you perform the migration to the new gateway, you must configure the new gateway.
        /// Use <a>CreateVpnGateway</a> to create a virtual private gateway, or <a>CreateTransitGateway</a>
        /// to create a transit gateway.
        /// </para>
        ///  
        /// <para>
        /// This step is required when you migrate from a virtual private gateway with static
        /// routes to a transit gateway. 
        /// </para>
        ///  
        /// <para>
        /// You must delete the static routes before you migrate to the new gateway.
        /// </para>
        ///  
        /// <para>
        /// Keep a copy of the static route before you delete it. You will need to add back these
        /// routes to the transit gateway after the VPN connection migration is complete.
        /// </para>
        ///  
        /// <para>
        /// After you migrate to the new gateway, you might need to modify your VPC route table.
        /// Use <a>CreateRoute</a> and <a>DeleteRoute</a> to make the changes described in <a
        /// href="https://docs.aws.amazon.com/vpn/latest/s2svpn/modify-vpn-target.html#step-update-routing">Update
        /// VPC route tables</a> in the <i>Amazon Web Services Site-to-Site VPN User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// When the new gateway is a transit gateway, modify the transit gateway route table
        /// to allow traffic between the VPC and the Amazon Web Services Site-to-Site VPN connection.
        /// Use <a>CreateTransitGatewayRoute</a> to add the routes.
        /// </para>
        ///  
        /// <para>
        ///  If you deleted VPN static routes, you must add the static routes to the transit gateway
        /// route table.
        /// </para>
        ///  
        /// <para>
        /// After you perform this operation, the VPN endpoint's IP addresses on the Amazon Web
        /// Services side and the tunnel options remain intact. Your Amazon Web Services Site-to-Site
        /// VPN connection will be temporarily unavailable for a brief period while we provision
        /// the new endpoints.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpnConnection service method.</param>
        /// 
        /// <returns>The response from the ModifyVpnConnection service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnConnection">REST API Reference for ModifyVpnConnection Operation</seealso>
        public virtual ModifyVpnConnectionResponse ModifyVpnConnection(ModifyVpnConnectionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpnConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpnConnectionResponseUnmarshaller.Instance;

            return Invoke<ModifyVpnConnectionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpnConnection operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpnConnection operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpnConnection
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnConnection">REST API Reference for ModifyVpnConnection Operation</seealso>
        public virtual IAsyncResult BeginModifyVpnConnection(ModifyVpnConnectionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpnConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpnConnectionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpnConnection operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpnConnection.</param>
        /// 
        /// <returns>Returns a  ModifyVpnConnectionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnConnection">REST API Reference for ModifyVpnConnection Operation</seealso>
        public virtual ModifyVpnConnectionResponse EndModifyVpnConnection(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpnConnectionResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpnConnectionOptions

        /// <summary>
        /// Modifies the connection options for your Site-to-Site VPN connection.
        /// 
        ///  
        /// <para>
        /// When you modify the VPN connection options, the VPN endpoint IP addresses on the Amazon
        /// Web Services side do not change, and the tunnel options do not change. Your VPN connection
        /// will be temporarily unavailable for a brief period while the VPN connection is updated.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpnConnectionOptions service method.</param>
        /// 
        /// <returns>The response from the ModifyVpnConnectionOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnConnectionOptions">REST API Reference for ModifyVpnConnectionOptions Operation</seealso>
        public virtual ModifyVpnConnectionOptionsResponse ModifyVpnConnectionOptions(ModifyVpnConnectionOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpnConnectionOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpnConnectionOptionsResponseUnmarshaller.Instance;

            return Invoke<ModifyVpnConnectionOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpnConnectionOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpnConnectionOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpnConnectionOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnConnectionOptions">REST API Reference for ModifyVpnConnectionOptions Operation</seealso>
        public virtual IAsyncResult BeginModifyVpnConnectionOptions(ModifyVpnConnectionOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpnConnectionOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpnConnectionOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpnConnectionOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpnConnectionOptions.</param>
        /// 
        /// <returns>Returns a  ModifyVpnConnectionOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnConnectionOptions">REST API Reference for ModifyVpnConnectionOptions Operation</seealso>
        public virtual ModifyVpnConnectionOptionsResponse EndModifyVpnConnectionOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpnConnectionOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpnTunnelCertificate

        /// <summary>
        /// Modifies the VPN tunnel endpoint certificate.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpnTunnelCertificate service method.</param>
        /// 
        /// <returns>The response from the ModifyVpnTunnelCertificate service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnTunnelCertificate">REST API Reference for ModifyVpnTunnelCertificate Operation</seealso>
        public virtual ModifyVpnTunnelCertificateResponse ModifyVpnTunnelCertificate(ModifyVpnTunnelCertificateRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpnTunnelCertificateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpnTunnelCertificateResponseUnmarshaller.Instance;

            return Invoke<ModifyVpnTunnelCertificateResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpnTunnelCertificate operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpnTunnelCertificate operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpnTunnelCertificate
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnTunnelCertificate">REST API Reference for ModifyVpnTunnelCertificate Operation</seealso>
        public virtual IAsyncResult BeginModifyVpnTunnelCertificate(ModifyVpnTunnelCertificateRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpnTunnelCertificateRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpnTunnelCertificateResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpnTunnelCertificate operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpnTunnelCertificate.</param>
        /// 
        /// <returns>Returns a  ModifyVpnTunnelCertificateResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnTunnelCertificate">REST API Reference for ModifyVpnTunnelCertificate Operation</seealso>
        public virtual ModifyVpnTunnelCertificateResponse EndModifyVpnTunnelCertificate(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpnTunnelCertificateResponse>(asyncResult);
        }

        #endregion
        
        #region  ModifyVpnTunnelOptions

        /// <summary>
        /// Modifies the options for a VPN tunnel in an Amazon Web Services Site-to-Site VPN connection.
        /// You can modify multiple options for a tunnel in a single request, but you can only
        /// modify one tunnel at a time. For more information, see <a href="https://docs.aws.amazon.com/vpn/latest/s2svpn/VPNTunnels.html">Site-to-Site
        /// VPN tunnel options for your Site-to-Site VPN connection</a> in the <i>Amazon Web Services
        /// Site-to-Site VPN User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpnTunnelOptions service method.</param>
        /// 
        /// <returns>The response from the ModifyVpnTunnelOptions service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnTunnelOptions">REST API Reference for ModifyVpnTunnelOptions Operation</seealso>
        public virtual ModifyVpnTunnelOptionsResponse ModifyVpnTunnelOptions(ModifyVpnTunnelOptionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpnTunnelOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpnTunnelOptionsResponseUnmarshaller.Instance;

            return Invoke<ModifyVpnTunnelOptionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ModifyVpnTunnelOptions operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ModifyVpnTunnelOptions operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndModifyVpnTunnelOptions
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnTunnelOptions">REST API Reference for ModifyVpnTunnelOptions Operation</seealso>
        public virtual IAsyncResult BeginModifyVpnTunnelOptions(ModifyVpnTunnelOptionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ModifyVpnTunnelOptionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ModifyVpnTunnelOptionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ModifyVpnTunnelOptions operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginModifyVpnTunnelOptions.</param>
        /// 
        /// <returns>Returns a  ModifyVpnTunnelOptionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ModifyVpnTunnelOptions">REST API Reference for ModifyVpnTunnelOptions Operation</seealso>
        public virtual ModifyVpnTunnelOptionsResponse EndModifyVpnTunnelOptions(IAsyncResult asyncResult)
        {
            return EndInvoke<ModifyVpnTunnelOptionsResponse>(asyncResult);
        }

        #endregion
        
        #region  MonitorInstances

        /// <summary>
        /// Enables detailed monitoring for a running instance. Otherwise, basic monitoring is
        /// enabled. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch.html">Monitor
        /// your instances using CloudWatch</a> in the <i>Amazon EC2 User Guide</i>.
        /// 
        ///  
        /// <para>
        /// To disable detailed monitoring, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_UnmonitorInstances.html">UnmonitorInstances</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the MonitorInstances service method.</param>
        /// 
        /// <returns>The response from the MonitorInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MonitorInstances">REST API Reference for MonitorInstances Operation</seealso>
        public virtual MonitorInstancesResponse MonitorInstances(MonitorInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = MonitorInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = MonitorInstancesResponseUnmarshaller.Instance;

            return Invoke<MonitorInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the MonitorInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the MonitorInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndMonitorInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MonitorInstances">REST API Reference for MonitorInstances Operation</seealso>
        public virtual IAsyncResult BeginMonitorInstances(MonitorInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = MonitorInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = MonitorInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  MonitorInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginMonitorInstances.</param>
        /// 
        /// <returns>Returns a  MonitorInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MonitorInstances">REST API Reference for MonitorInstances Operation</seealso>
        public virtual MonitorInstancesResponse EndMonitorInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<MonitorInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  MoveAddressToVpc

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Moves an Elastic IP address from the EC2-Classic platform to the EC2-VPC platform.
        /// The Elastic IP address must be allocated to your account for more than 24 hours, and
        /// it must not be associated with an instance. After the Elastic IP address is moved,
        /// it is no longer available for use in the EC2-Classic platform, unless you move it
        /// back using the <a>RestoreAddressToClassic</a> request. You cannot move an Elastic
        /// IP address that was originally allocated for use in the EC2-VPC platform to the EC2-Classic
        /// platform.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the MoveAddressToVpc service method.</param>
        /// 
        /// <returns>The response from the MoveAddressToVpc service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MoveAddressToVpc">REST API Reference for MoveAddressToVpc Operation</seealso>
        public virtual MoveAddressToVpcResponse MoveAddressToVpc(MoveAddressToVpcRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = MoveAddressToVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = MoveAddressToVpcResponseUnmarshaller.Instance;

            return Invoke<MoveAddressToVpcResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the MoveAddressToVpc operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the MoveAddressToVpc operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndMoveAddressToVpc
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MoveAddressToVpc">REST API Reference for MoveAddressToVpc Operation</seealso>
        public virtual IAsyncResult BeginMoveAddressToVpc(MoveAddressToVpcRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = MoveAddressToVpcRequestMarshaller.Instance;
            options.ResponseUnmarshaller = MoveAddressToVpcResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  MoveAddressToVpc operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginMoveAddressToVpc.</param>
        /// 
        /// <returns>Returns a  MoveAddressToVpcResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MoveAddressToVpc">REST API Reference for MoveAddressToVpc Operation</seealso>
        public virtual MoveAddressToVpcResponse EndMoveAddressToVpc(IAsyncResult asyncResult)
        {
            return EndInvoke<MoveAddressToVpcResponse>(asyncResult);
        }

        #endregion
        
        #region  MoveByoipCidrToIpam

        /// <summary>
        /// Move a BYOIPv4 CIDR to IPAM from a public IPv4 pool.
        /// 
        ///  
        /// <para>
        /// If you already have a BYOIPv4 CIDR with Amazon Web Services, you can move the CIDR
        /// to IPAM from a public IPv4 pool. You cannot move an IPv6 CIDR to IPAM. If you are
        /// bringing a new IP address to Amazon Web Services for the first time, complete the
        /// steps in <a href="https://docs.aws.amazon.com/vpc/latest/ipam/tutorials-byoip-ipam.html">Tutorial:
        /// BYOIP address CIDRs to IPAM</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the MoveByoipCidrToIpam service method.</param>
        /// 
        /// <returns>The response from the MoveByoipCidrToIpam service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MoveByoipCidrToIpam">REST API Reference for MoveByoipCidrToIpam Operation</seealso>
        public virtual MoveByoipCidrToIpamResponse MoveByoipCidrToIpam(MoveByoipCidrToIpamRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = MoveByoipCidrToIpamRequestMarshaller.Instance;
            options.ResponseUnmarshaller = MoveByoipCidrToIpamResponseUnmarshaller.Instance;

            return Invoke<MoveByoipCidrToIpamResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the MoveByoipCidrToIpam operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the MoveByoipCidrToIpam operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndMoveByoipCidrToIpam
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MoveByoipCidrToIpam">REST API Reference for MoveByoipCidrToIpam Operation</seealso>
        public virtual IAsyncResult BeginMoveByoipCidrToIpam(MoveByoipCidrToIpamRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = MoveByoipCidrToIpamRequestMarshaller.Instance;
            options.ResponseUnmarshaller = MoveByoipCidrToIpamResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  MoveByoipCidrToIpam operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginMoveByoipCidrToIpam.</param>
        /// 
        /// <returns>Returns a  MoveByoipCidrToIpamResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/MoveByoipCidrToIpam">REST API Reference for MoveByoipCidrToIpam Operation</seealso>
        public virtual MoveByoipCidrToIpamResponse EndMoveByoipCidrToIpam(IAsyncResult asyncResult)
        {
            return EndInvoke<MoveByoipCidrToIpamResponse>(asyncResult);
        }

        #endregion
        
        #region  ProvisionByoipCidr

        /// <summary>
        /// Provisions an IPv4 or IPv6 address range for use with your Amazon Web Services resources
        /// through bring your own IP addresses (BYOIP) and creates a corresponding address pool.
        /// After the address range is provisioned, it is ready to be advertised using <a>AdvertiseByoipCidr</a>.
        /// 
        ///  
        /// <para>
        /// Amazon Web Services verifies that you own the address range and are authorized to
        /// advertise it. You must ensure that the address range is registered to you and that
        /// you created an RPKI ROA to authorize Amazon ASNs 16509 and 14618 to advertise the
        /// address range. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html">Bring
        /// your own IP addresses (BYOIP)</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// Provisioning an address range is an asynchronous operation, so the call returns immediately,
        /// but the address range is not ready to use until its status changes from <code>pending-provision</code>
        /// to <code>provisioned</code>. To monitor the status of an address range, use <a>DescribeByoipCidrs</a>.
        /// To allocate an Elastic IP address from your IPv4 address pool, use <a>AllocateAddress</a>
        /// with either the specific address from the address pool or the ID of the address pool.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ProvisionByoipCidr service method.</param>
        /// 
        /// <returns>The response from the ProvisionByoipCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionByoipCidr">REST API Reference for ProvisionByoipCidr Operation</seealso>
        public virtual ProvisionByoipCidrResponse ProvisionByoipCidr(ProvisionByoipCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ProvisionByoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ProvisionByoipCidrResponseUnmarshaller.Instance;

            return Invoke<ProvisionByoipCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ProvisionByoipCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ProvisionByoipCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndProvisionByoipCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionByoipCidr">REST API Reference for ProvisionByoipCidr Operation</seealso>
        public virtual IAsyncResult BeginProvisionByoipCidr(ProvisionByoipCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ProvisionByoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ProvisionByoipCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ProvisionByoipCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginProvisionByoipCidr.</param>
        /// 
        /// <returns>Returns a  ProvisionByoipCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionByoipCidr">REST API Reference for ProvisionByoipCidr Operation</seealso>
        public virtual ProvisionByoipCidrResponse EndProvisionByoipCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<ProvisionByoipCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  ProvisionIpamPoolCidr

        /// <summary>
        /// Provision a CIDR to an IPAM pool. You can use this action to provision new CIDRs to
        /// a top-level pool or to transfer a CIDR from a top-level pool to a pool within it.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/prov-cidr-ipam.html">Provision
        /// CIDRs to pools</a> in the <i>Amazon VPC IPAM User Guide</i>. 
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ProvisionIpamPoolCidr service method.</param>
        /// 
        /// <returns>The response from the ProvisionIpamPoolCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionIpamPoolCidr">REST API Reference for ProvisionIpamPoolCidr Operation</seealso>
        public virtual ProvisionIpamPoolCidrResponse ProvisionIpamPoolCidr(ProvisionIpamPoolCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ProvisionIpamPoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ProvisionIpamPoolCidrResponseUnmarshaller.Instance;

            return Invoke<ProvisionIpamPoolCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ProvisionIpamPoolCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ProvisionIpamPoolCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndProvisionIpamPoolCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionIpamPoolCidr">REST API Reference for ProvisionIpamPoolCidr Operation</seealso>
        public virtual IAsyncResult BeginProvisionIpamPoolCidr(ProvisionIpamPoolCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ProvisionIpamPoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ProvisionIpamPoolCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ProvisionIpamPoolCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginProvisionIpamPoolCidr.</param>
        /// 
        /// <returns>Returns a  ProvisionIpamPoolCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionIpamPoolCidr">REST API Reference for ProvisionIpamPoolCidr Operation</seealso>
        public virtual ProvisionIpamPoolCidrResponse EndProvisionIpamPoolCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<ProvisionIpamPoolCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  ProvisionPublicIpv4PoolCidr

        /// <summary>
        /// Provision a CIDR to a public IPv4 pool.
        /// 
        ///  
        /// <para>
        /// For more information about IPAM, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/what-is-it-ipam.html">What
        /// is IPAM?</a> in the <i>Amazon VPC IPAM User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ProvisionPublicIpv4PoolCidr service method.</param>
        /// 
        /// <returns>The response from the ProvisionPublicIpv4PoolCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionPublicIpv4PoolCidr">REST API Reference for ProvisionPublicIpv4PoolCidr Operation</seealso>
        public virtual ProvisionPublicIpv4PoolCidrResponse ProvisionPublicIpv4PoolCidr(ProvisionPublicIpv4PoolCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ProvisionPublicIpv4PoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ProvisionPublicIpv4PoolCidrResponseUnmarshaller.Instance;

            return Invoke<ProvisionPublicIpv4PoolCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ProvisionPublicIpv4PoolCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ProvisionPublicIpv4PoolCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndProvisionPublicIpv4PoolCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionPublicIpv4PoolCidr">REST API Reference for ProvisionPublicIpv4PoolCidr Operation</seealso>
        public virtual IAsyncResult BeginProvisionPublicIpv4PoolCidr(ProvisionPublicIpv4PoolCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ProvisionPublicIpv4PoolCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ProvisionPublicIpv4PoolCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ProvisionPublicIpv4PoolCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginProvisionPublicIpv4PoolCidr.</param>
        /// 
        /// <returns>Returns a  ProvisionPublicIpv4PoolCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ProvisionPublicIpv4PoolCidr">REST API Reference for ProvisionPublicIpv4PoolCidr Operation</seealso>
        public virtual ProvisionPublicIpv4PoolCidrResponse EndProvisionPublicIpv4PoolCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<ProvisionPublicIpv4PoolCidrResponse>(asyncResult);
        }

        #endregion
        
        #region  PurchaseHostReservation

        /// <summary>
        /// Purchase a reservation with configurations that match those of your Dedicated Host.
        /// You must have active Dedicated Hosts in your account before you purchase a reservation.
        /// This action results in the specified reservation being purchased and charged to your
        /// account.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the PurchaseHostReservation service method.</param>
        /// 
        /// <returns>The response from the PurchaseHostReservation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseHostReservation">REST API Reference for PurchaseHostReservation Operation</seealso>
        public virtual PurchaseHostReservationResponse PurchaseHostReservation(PurchaseHostReservationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PurchaseHostReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PurchaseHostReservationResponseUnmarshaller.Instance;

            return Invoke<PurchaseHostReservationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the PurchaseHostReservation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the PurchaseHostReservation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPurchaseHostReservation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseHostReservation">REST API Reference for PurchaseHostReservation Operation</seealso>
        public virtual IAsyncResult BeginPurchaseHostReservation(PurchaseHostReservationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PurchaseHostReservationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PurchaseHostReservationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  PurchaseHostReservation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginPurchaseHostReservation.</param>
        /// 
        /// <returns>Returns a  PurchaseHostReservationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseHostReservation">REST API Reference for PurchaseHostReservation Operation</seealso>
        public virtual PurchaseHostReservationResponse EndPurchaseHostReservation(IAsyncResult asyncResult)
        {
            return EndInvoke<PurchaseHostReservationResponse>(asyncResult);
        }

        #endregion
        
        #region  PurchaseReservedInstancesOffering

        /// <summary>
        /// Purchases a Reserved Instance for use with your account. With Reserved Instances,
        /// you pay a lower hourly rate compared to On-Demand instance pricing.
        /// 
        ///  
        /// <para>
        /// Use <a>DescribeReservedInstancesOfferings</a> to get a list of Reserved Instance offerings
        /// that match your specifications. After you've purchased a Reserved Instance, you can
        /// check for your new Reserved Instance with <a>DescribeReservedInstances</a>.
        /// </para>
        ///  
        /// <para>
        /// To queue a purchase for a future date and time, specify a purchase time. If you do
        /// not specify a purchase time, the default is the current time.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts-on-demand-reserved-instances.html">Reserved
        /// Instances</a> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ri-market-general.html">Reserved
        /// Instance Marketplace</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the PurchaseReservedInstancesOffering service method.</param>
        /// 
        /// <returns>The response from the PurchaseReservedInstancesOffering service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseReservedInstancesOffering">REST API Reference for PurchaseReservedInstancesOffering Operation</seealso>
        public virtual PurchaseReservedInstancesOfferingResponse PurchaseReservedInstancesOffering(PurchaseReservedInstancesOfferingRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PurchaseReservedInstancesOfferingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PurchaseReservedInstancesOfferingResponseUnmarshaller.Instance;

            return Invoke<PurchaseReservedInstancesOfferingResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the PurchaseReservedInstancesOffering operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the PurchaseReservedInstancesOffering operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPurchaseReservedInstancesOffering
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseReservedInstancesOffering">REST API Reference for PurchaseReservedInstancesOffering Operation</seealso>
        public virtual IAsyncResult BeginPurchaseReservedInstancesOffering(PurchaseReservedInstancesOfferingRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PurchaseReservedInstancesOfferingRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PurchaseReservedInstancesOfferingResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  PurchaseReservedInstancesOffering operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginPurchaseReservedInstancesOffering.</param>
        /// 
        /// <returns>Returns a  PurchaseReservedInstancesOfferingResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseReservedInstancesOffering">REST API Reference for PurchaseReservedInstancesOffering Operation</seealso>
        public virtual PurchaseReservedInstancesOfferingResponse EndPurchaseReservedInstancesOffering(IAsyncResult asyncResult)
        {
            return EndInvoke<PurchaseReservedInstancesOfferingResponse>(asyncResult);
        }

        #endregion
        
        #region  PurchaseScheduledInstances

        /// <summary>
        /// <note> 
        /// <para>
        /// You can no longer purchase Scheduled Instances.
        /// </para>
        ///  </note> 
        /// <para>
        /// Purchases the Scheduled Instances with the specified schedule.
        /// </para>
        ///  
        /// <para>
        /// Scheduled Instances enable you to purchase Amazon EC2 compute capacity by the hour
        /// for a one-year term. Before you can purchase a Scheduled Instance, you must call <a>DescribeScheduledInstanceAvailability</a>
        /// to check for available schedules and obtain a purchase token. After you purchase a
        /// Scheduled Instance, you must call <a>RunScheduledInstances</a> during each scheduled
        /// time period.
        /// </para>
        ///  
        /// <para>
        /// After you purchase a Scheduled Instance, you can't cancel, modify, or resell your
        /// purchase.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the PurchaseScheduledInstances service method.</param>
        /// 
        /// <returns>The response from the PurchaseScheduledInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseScheduledInstances">REST API Reference for PurchaseScheduledInstances Operation</seealso>
        public virtual PurchaseScheduledInstancesResponse PurchaseScheduledInstances(PurchaseScheduledInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PurchaseScheduledInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PurchaseScheduledInstancesResponseUnmarshaller.Instance;

            return Invoke<PurchaseScheduledInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the PurchaseScheduledInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the PurchaseScheduledInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndPurchaseScheduledInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseScheduledInstances">REST API Reference for PurchaseScheduledInstances Operation</seealso>
        public virtual IAsyncResult BeginPurchaseScheduledInstances(PurchaseScheduledInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = PurchaseScheduledInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = PurchaseScheduledInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  PurchaseScheduledInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginPurchaseScheduledInstances.</param>
        /// 
        /// <returns>Returns a  PurchaseScheduledInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/PurchaseScheduledInstances">REST API Reference for PurchaseScheduledInstances Operation</seealso>
        public virtual PurchaseScheduledInstancesResponse EndPurchaseScheduledInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<PurchaseScheduledInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  RebootInstances

        /// <summary>
        /// Requests a reboot of the specified instances. This operation is asynchronous; it only
        /// queues a request to reboot the specified instances. The operation succeeds if the
        /// instances are valid and belong to you. Requests to reboot terminated instances are
        /// ignored.
        /// 
        ///  
        /// <para>
        /// If an instance does not cleanly shut down within a few minutes, Amazon EC2 performs
        /// a hard reboot.
        /// </para>
        ///  
        /// <para>
        /// For more information about troubleshooting, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html">Troubleshoot
        /// an unreachable instance</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RebootInstances service method.</param>
        /// 
        /// <returns>The response from the RebootInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RebootInstances">REST API Reference for RebootInstances Operation</seealso>
        public virtual RebootInstancesResponse RebootInstances(RebootInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RebootInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RebootInstancesResponseUnmarshaller.Instance;

            return Invoke<RebootInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RebootInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RebootInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRebootInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RebootInstances">REST API Reference for RebootInstances Operation</seealso>
        public virtual IAsyncResult BeginRebootInstances(RebootInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RebootInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RebootInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RebootInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRebootInstances.</param>
        /// 
        /// <returns>Returns a  RebootInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RebootInstances">REST API Reference for RebootInstances Operation</seealso>
        public virtual RebootInstancesResponse EndRebootInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<RebootInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  RegisterImage

        /// <summary>
        /// Registers an AMI. When you're creating an AMI, this is the final step you must complete
        /// before you can launch an instance from the AMI. For more information about creating
        /// AMIs, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami.html">Create
        /// your own AMI</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// 
        ///  <note> 
        /// <para>
        /// For Amazon EBS-backed instances, <a>CreateImage</a> creates and registers the AMI
        /// in a single request, so you don't have to register the AMI yourself. We recommend
        /// that you always use <a>CreateImage</a> unless you have a specific reason to use RegisterImage.
        /// </para>
        ///  </note> 
        /// <para>
        /// If needed, you can deregister an AMI at any time. Any modifications you make to an
        /// AMI backed by an instance store volume invalidates its registration. If you make changes
        /// to an image, deregister the previous image and register the new image.
        /// </para>
        ///  
        /// <para>
        ///  <b>Register a snapshot of a root device volume</b> 
        /// </para>
        ///  
        /// <para>
        /// You can use <code>RegisterImage</code> to create an Amazon EBS-backed Linux AMI from
        /// a snapshot of a root device volume. You specify the snapshot using a block device
        /// mapping. You can't set the encryption state of the volume using the block device mapping.
        /// If the snapshot is encrypted, or encryption by default is enabled, the root volume
        /// of an instance launched from the AMI is encrypted.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html#creating-launching-ami-from-snapshot">Create
        /// a Linux AMI from a snapshot</a> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AMIEncryption.html">Use
        /// encryption with Amazon EBS-backed AMIs</a> in the <i>Amazon Elastic Compute Cloud
        /// User Guide</i>.
        /// </para>
        ///  
        /// <para>
        ///  <b>Amazon Web Services Marketplace product codes</b> 
        /// </para>
        ///  
        /// <para>
        /// If any snapshots have Amazon Web Services Marketplace product codes, they are copied
        /// to the new AMI.
        /// </para>
        ///  
        /// <para>
        /// Windows and some Linux distributions, such as Red Hat Enterprise Linux (RHEL) and
        /// SUSE Linux Enterprise Server (SLES), use the Amazon EC2 billing product code associated
        /// with an AMI to verify the subscription status for package updates. To create a new
        /// AMI for operating systems that require a billing product code, instead of registering
        /// the AMI, do the following to preserve the billing product code association:
        /// </para>
        ///  <ol> <li> 
        /// <para>
        /// Launch an instance from an existing AMI with that billing product code.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Customize the instance.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Create an AMI from the instance using <a>CreateImage</a>.
        /// </para>
        ///  </li> </ol> 
        /// <para>
        /// If you purchase a Reserved Instance to apply to an On-Demand Instance that was launched
        /// from an AMI with a billing product code, make sure that the Reserved Instance has
        /// the matching billing product code. If you purchase a Reserved Instance without the
        /// matching billing product code, the Reserved Instance will not be applied to the On-Demand
        /// Instance. For information about how to obtain the platform details and billing information
        /// of an AMI, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-billing-info.html">Understand
        /// AMI billing information</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RegisterImage service method.</param>
        /// 
        /// <returns>The response from the RegisterImage service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterImage">REST API Reference for RegisterImage Operation</seealso>
        public virtual RegisterImageResponse RegisterImage(RegisterImageRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterImageResponseUnmarshaller.Instance;

            return Invoke<RegisterImageResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RegisterImage operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RegisterImage operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterImage
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterImage">REST API Reference for RegisterImage Operation</seealso>
        public virtual IAsyncResult BeginRegisterImage(RegisterImageRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterImageRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterImageResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RegisterImage operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRegisterImage.</param>
        /// 
        /// <returns>Returns a  RegisterImageResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterImage">REST API Reference for RegisterImage Operation</seealso>
        public virtual RegisterImageResponse EndRegisterImage(IAsyncResult asyncResult)
        {
            return EndInvoke<RegisterImageResponse>(asyncResult);
        }

        #endregion
        
        #region  RegisterInstanceEventNotificationAttributes

        /// <summary>
        /// Registers a set of tag keys to include in scheduled event notifications for your resources.
        /// 
        /// 
        ///  
        /// <para>
        /// To remove tags, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeregisterInstanceEventNotificationAttributes.html">DeregisterInstanceEventNotificationAttributes</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RegisterInstanceEventNotificationAttributes service method.</param>
        /// 
        /// <returns>The response from the RegisterInstanceEventNotificationAttributes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterInstanceEventNotificationAttributes">REST API Reference for RegisterInstanceEventNotificationAttributes Operation</seealso>
        public virtual RegisterInstanceEventNotificationAttributesResponse RegisterInstanceEventNotificationAttributes(RegisterInstanceEventNotificationAttributesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterInstanceEventNotificationAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterInstanceEventNotificationAttributesResponseUnmarshaller.Instance;

            return Invoke<RegisterInstanceEventNotificationAttributesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RegisterInstanceEventNotificationAttributes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RegisterInstanceEventNotificationAttributes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterInstanceEventNotificationAttributes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterInstanceEventNotificationAttributes">REST API Reference for RegisterInstanceEventNotificationAttributes Operation</seealso>
        public virtual IAsyncResult BeginRegisterInstanceEventNotificationAttributes(RegisterInstanceEventNotificationAttributesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterInstanceEventNotificationAttributesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterInstanceEventNotificationAttributesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RegisterInstanceEventNotificationAttributes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRegisterInstanceEventNotificationAttributes.</param>
        /// 
        /// <returns>Returns a  RegisterInstanceEventNotificationAttributesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterInstanceEventNotificationAttributes">REST API Reference for RegisterInstanceEventNotificationAttributes Operation</seealso>
        public virtual RegisterInstanceEventNotificationAttributesResponse EndRegisterInstanceEventNotificationAttributes(IAsyncResult asyncResult)
        {
            return EndInvoke<RegisterInstanceEventNotificationAttributesResponse>(asyncResult);
        }

        #endregion
        
        #region  RegisterTransitGatewayMulticastGroupMembers

        /// <summary>
        /// Registers members (network interfaces) with the transit gateway multicast group. A
        /// member is a network interface associated with a supported EC2 instance that receives
        /// multicast traffic. For information about supported instances, see <a href="https://docs.aws.amazon.com/vpc/latest/tgw/transit-gateway-limits.html#multicast-limits">Multicast
        /// Consideration</a> in <i>Amazon VPC Transit Gateways</i>.
        /// 
        ///  
        /// <para>
        /// After you add the members, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SearchTransitGatewayMulticastGroups.html">SearchTransitGatewayMulticastGroups</a>
        /// to verify that the members were added to the transit gateway multicast group.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RegisterTransitGatewayMulticastGroupMembers service method.</param>
        /// 
        /// <returns>The response from the RegisterTransitGatewayMulticastGroupMembers service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterTransitGatewayMulticastGroupMembers">REST API Reference for RegisterTransitGatewayMulticastGroupMembers Operation</seealso>
        public virtual RegisterTransitGatewayMulticastGroupMembersResponse RegisterTransitGatewayMulticastGroupMembers(RegisterTransitGatewayMulticastGroupMembersRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterTransitGatewayMulticastGroupMembersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterTransitGatewayMulticastGroupMembersResponseUnmarshaller.Instance;

            return Invoke<RegisterTransitGatewayMulticastGroupMembersResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RegisterTransitGatewayMulticastGroupMembers operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RegisterTransitGatewayMulticastGroupMembers operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterTransitGatewayMulticastGroupMembers
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterTransitGatewayMulticastGroupMembers">REST API Reference for RegisterTransitGatewayMulticastGroupMembers Operation</seealso>
        public virtual IAsyncResult BeginRegisterTransitGatewayMulticastGroupMembers(RegisterTransitGatewayMulticastGroupMembersRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterTransitGatewayMulticastGroupMembersRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterTransitGatewayMulticastGroupMembersResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RegisterTransitGatewayMulticastGroupMembers operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRegisterTransitGatewayMulticastGroupMembers.</param>
        /// 
        /// <returns>Returns a  RegisterTransitGatewayMulticastGroupMembersResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterTransitGatewayMulticastGroupMembers">REST API Reference for RegisterTransitGatewayMulticastGroupMembers Operation</seealso>
        public virtual RegisterTransitGatewayMulticastGroupMembersResponse EndRegisterTransitGatewayMulticastGroupMembers(IAsyncResult asyncResult)
        {
            return EndInvoke<RegisterTransitGatewayMulticastGroupMembersResponse>(asyncResult);
        }

        #endregion
        
        #region  RegisterTransitGatewayMulticastGroupSources

        /// <summary>
        /// Registers sources (network interfaces) with the specified transit gateway multicast
        /// group.
        /// 
        ///  
        /// <para>
        /// A multicast source is a network interface attached to a supported instance that sends
        /// multicast traffic. For information about supported instances, see <a href="https://docs.aws.amazon.com/vpc/latest/tgw/transit-gateway-limits.html#multicast-limits">Multicast
        /// Considerations</a> in <i>Amazon VPC Transit Gateways</i>.
        /// </para>
        ///  
        /// <para>
        /// After you add the source, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SearchTransitGatewayMulticastGroups.html">SearchTransitGatewayMulticastGroups</a>
        /// to verify that the source was added to the multicast group.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RegisterTransitGatewayMulticastGroupSources service method.</param>
        /// 
        /// <returns>The response from the RegisterTransitGatewayMulticastGroupSources service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterTransitGatewayMulticastGroupSources">REST API Reference for RegisterTransitGatewayMulticastGroupSources Operation</seealso>
        public virtual RegisterTransitGatewayMulticastGroupSourcesResponse RegisterTransitGatewayMulticastGroupSources(RegisterTransitGatewayMulticastGroupSourcesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterTransitGatewayMulticastGroupSourcesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterTransitGatewayMulticastGroupSourcesResponseUnmarshaller.Instance;

            return Invoke<RegisterTransitGatewayMulticastGroupSourcesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RegisterTransitGatewayMulticastGroupSources operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RegisterTransitGatewayMulticastGroupSources operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterTransitGatewayMulticastGroupSources
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterTransitGatewayMulticastGroupSources">REST API Reference for RegisterTransitGatewayMulticastGroupSources Operation</seealso>
        public virtual IAsyncResult BeginRegisterTransitGatewayMulticastGroupSources(RegisterTransitGatewayMulticastGroupSourcesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RegisterTransitGatewayMulticastGroupSourcesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RegisterTransitGatewayMulticastGroupSourcesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RegisterTransitGatewayMulticastGroupSources operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRegisterTransitGatewayMulticastGroupSources.</param>
        /// 
        /// <returns>Returns a  RegisterTransitGatewayMulticastGroupSourcesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RegisterTransitGatewayMulticastGroupSources">REST API Reference for RegisterTransitGatewayMulticastGroupSources Operation</seealso>
        public virtual RegisterTransitGatewayMulticastGroupSourcesResponse EndRegisterTransitGatewayMulticastGroupSources(IAsyncResult asyncResult)
        {
            return EndInvoke<RegisterTransitGatewayMulticastGroupSourcesResponse>(asyncResult);
        }

        #endregion
        
        #region  RejectTransitGatewayMulticastDomainAssociations

        /// <summary>
        /// Rejects a request to associate cross-account subnets with a transit gateway multicast
        /// domain.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RejectTransitGatewayMulticastDomainAssociations service method.</param>
        /// 
        /// <returns>The response from the RejectTransitGatewayMulticastDomainAssociations service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayMulticastDomainAssociations">REST API Reference for RejectTransitGatewayMulticastDomainAssociations Operation</seealso>
        public virtual RejectTransitGatewayMulticastDomainAssociationsResponse RejectTransitGatewayMulticastDomainAssociations(RejectTransitGatewayMulticastDomainAssociationsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance;

            return Invoke<RejectTransitGatewayMulticastDomainAssociationsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RejectTransitGatewayMulticastDomainAssociations operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RejectTransitGatewayMulticastDomainAssociations operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRejectTransitGatewayMulticastDomainAssociations
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayMulticastDomainAssociations">REST API Reference for RejectTransitGatewayMulticastDomainAssociations Operation</seealso>
        public virtual IAsyncResult BeginRejectTransitGatewayMulticastDomainAssociations(RejectTransitGatewayMulticastDomainAssociationsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RejectTransitGatewayMulticastDomainAssociations operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRejectTransitGatewayMulticastDomainAssociations.</param>
        /// 
        /// <returns>Returns a  RejectTransitGatewayMulticastDomainAssociationsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayMulticastDomainAssociations">REST API Reference for RejectTransitGatewayMulticastDomainAssociations Operation</seealso>
        public virtual RejectTransitGatewayMulticastDomainAssociationsResponse EndRejectTransitGatewayMulticastDomainAssociations(IAsyncResult asyncResult)
        {
            return EndInvoke<RejectTransitGatewayMulticastDomainAssociationsResponse>(asyncResult);
        }

        #endregion
        
        #region  RejectTransitGatewayPeeringAttachment

        /// <summary>
        /// Rejects a transit gateway peering attachment request.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RejectTransitGatewayPeeringAttachment service method.</param>
        /// 
        /// <returns>The response from the RejectTransitGatewayPeeringAttachment service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayPeeringAttachment">REST API Reference for RejectTransitGatewayPeeringAttachment Operation</seealso>
        public virtual RejectTransitGatewayPeeringAttachmentResponse RejectTransitGatewayPeeringAttachment(RejectTransitGatewayPeeringAttachmentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectTransitGatewayPeeringAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance;

            return Invoke<RejectTransitGatewayPeeringAttachmentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RejectTransitGatewayPeeringAttachment operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RejectTransitGatewayPeeringAttachment operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRejectTransitGatewayPeeringAttachment
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayPeeringAttachment">REST API Reference for RejectTransitGatewayPeeringAttachment Operation</seealso>
        public virtual IAsyncResult BeginRejectTransitGatewayPeeringAttachment(RejectTransitGatewayPeeringAttachmentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectTransitGatewayPeeringAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectTransitGatewayPeeringAttachmentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RejectTransitGatewayPeeringAttachment operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRejectTransitGatewayPeeringAttachment.</param>
        /// 
        /// <returns>Returns a  RejectTransitGatewayPeeringAttachmentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayPeeringAttachment">REST API Reference for RejectTransitGatewayPeeringAttachment Operation</seealso>
        public virtual RejectTransitGatewayPeeringAttachmentResponse EndRejectTransitGatewayPeeringAttachment(IAsyncResult asyncResult)
        {
            return EndInvoke<RejectTransitGatewayPeeringAttachmentResponse>(asyncResult);
        }

        #endregion
        
        #region  RejectTransitGatewayVpcAttachment

        /// <summary>
        /// Rejects a request to attach a VPC to a transit gateway.
        /// 
        ///  
        /// <para>
        /// The VPC attachment must be in the <code>pendingAcceptance</code> state. Use <a>DescribeTransitGatewayVpcAttachments</a>
        /// to view your pending VPC attachment requests. Use <a>AcceptTransitGatewayVpcAttachment</a>
        /// to accept a VPC attachment request.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RejectTransitGatewayVpcAttachment service method.</param>
        /// 
        /// <returns>The response from the RejectTransitGatewayVpcAttachment service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayVpcAttachment">REST API Reference for RejectTransitGatewayVpcAttachment Operation</seealso>
        public virtual RejectTransitGatewayVpcAttachmentResponse RejectTransitGatewayVpcAttachment(RejectTransitGatewayVpcAttachmentRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return Invoke<RejectTransitGatewayVpcAttachmentResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RejectTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RejectTransitGatewayVpcAttachment operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRejectTransitGatewayVpcAttachment
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayVpcAttachment">REST API Reference for RejectTransitGatewayVpcAttachment Operation</seealso>
        public virtual IAsyncResult BeginRejectTransitGatewayVpcAttachment(RejectTransitGatewayVpcAttachmentRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectTransitGatewayVpcAttachmentRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RejectTransitGatewayVpcAttachment operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRejectTransitGatewayVpcAttachment.</param>
        /// 
        /// <returns>Returns a  RejectTransitGatewayVpcAttachmentResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectTransitGatewayVpcAttachment">REST API Reference for RejectTransitGatewayVpcAttachment Operation</seealso>
        public virtual RejectTransitGatewayVpcAttachmentResponse EndRejectTransitGatewayVpcAttachment(IAsyncResult asyncResult)
        {
            return EndInvoke<RejectTransitGatewayVpcAttachmentResponse>(asyncResult);
        }

        #endregion
        
        #region  RejectVpcEndpointConnections

        /// <summary>
        /// Rejects VPC endpoint connection requests to your VPC endpoint service.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RejectVpcEndpointConnections service method.</param>
        /// 
        /// <returns>The response from the RejectVpcEndpointConnections service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectVpcEndpointConnections">REST API Reference for RejectVpcEndpointConnections Operation</seealso>
        public virtual RejectVpcEndpointConnectionsResponse RejectVpcEndpointConnections(RejectVpcEndpointConnectionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectVpcEndpointConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectVpcEndpointConnectionsResponseUnmarshaller.Instance;

            return Invoke<RejectVpcEndpointConnectionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RejectVpcEndpointConnections operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RejectVpcEndpointConnections operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRejectVpcEndpointConnections
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectVpcEndpointConnections">REST API Reference for RejectVpcEndpointConnections Operation</seealso>
        public virtual IAsyncResult BeginRejectVpcEndpointConnections(RejectVpcEndpointConnectionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectVpcEndpointConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectVpcEndpointConnectionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RejectVpcEndpointConnections operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRejectVpcEndpointConnections.</param>
        /// 
        /// <returns>Returns a  RejectVpcEndpointConnectionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectVpcEndpointConnections">REST API Reference for RejectVpcEndpointConnections Operation</seealso>
        public virtual RejectVpcEndpointConnectionsResponse EndRejectVpcEndpointConnections(IAsyncResult asyncResult)
        {
            return EndInvoke<RejectVpcEndpointConnectionsResponse>(asyncResult);
        }

        #endregion
        
        #region  RejectVpcPeeringConnection

        /// <summary>
        /// Rejects a VPC peering connection request. The VPC peering connection must be in the
        /// <code>pending-acceptance</code> state. Use the <a>DescribeVpcPeeringConnections</a>
        /// request to view your outstanding VPC peering connection requests. To delete an active
        /// VPC peering connection, or to delete a VPC peering connection request that you initiated,
        /// use <a>DeleteVpcPeeringConnection</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RejectVpcPeeringConnection service method.</param>
        /// 
        /// <returns>The response from the RejectVpcPeeringConnection service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectVpcPeeringConnection">REST API Reference for RejectVpcPeeringConnection Operation</seealso>
        public virtual RejectVpcPeeringConnectionResponse RejectVpcPeeringConnection(RejectVpcPeeringConnectionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectVpcPeeringConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectVpcPeeringConnectionResponseUnmarshaller.Instance;

            return Invoke<RejectVpcPeeringConnectionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RejectVpcPeeringConnection operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RejectVpcPeeringConnection operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRejectVpcPeeringConnection
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectVpcPeeringConnection">REST API Reference for RejectVpcPeeringConnection Operation</seealso>
        public virtual IAsyncResult BeginRejectVpcPeeringConnection(RejectVpcPeeringConnectionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RejectVpcPeeringConnectionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RejectVpcPeeringConnectionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RejectVpcPeeringConnection operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRejectVpcPeeringConnection.</param>
        /// 
        /// <returns>Returns a  RejectVpcPeeringConnectionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RejectVpcPeeringConnection">REST API Reference for RejectVpcPeeringConnection Operation</seealso>
        public virtual RejectVpcPeeringConnectionResponse EndRejectVpcPeeringConnection(IAsyncResult asyncResult)
        {
            return EndInvoke<RejectVpcPeeringConnectionResponse>(asyncResult);
        }

        #endregion
        
        #region  ReleaseAddress

        /// <summary>
        /// Releases the specified Elastic IP address.
        /// 
        ///  
        /// <para>
        /// [Default VPC] Releasing an Elastic IP address automatically disassociates it from
        /// any instance that it's associated with. To disassociate an Elastic IP address without
        /// releasing it, use <a>DisassociateAddress</a>.
        /// </para>
        ///  
        /// <para>
        /// [Nondefault VPC] You must use <a>DisassociateAddress</a> to disassociate the Elastic
        /// IP address before you can release it. Otherwise, Amazon EC2 returns an error (<code>InvalidIPAddress.InUse</code>).
        /// </para>
        ///  
        /// <para>
        /// After releasing an Elastic IP address, it is released to the IP address pool. Be sure
        /// to update your DNS records and any servers or devices that communicate with the address.
        /// If you attempt to release an Elastic IP address that you already released, you'll
        /// get an <code>AuthFailure</code> error if the address is already allocated to another
        /// Amazon Web Services account.
        /// </para>
        ///  
        /// <para>
        /// After you release an Elastic IP address, you might be able to recover it. For more
        /// information, see <a>AllocateAddress</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReleaseAddress service method.</param>
        /// 
        /// <returns>The response from the ReleaseAddress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseAddress">REST API Reference for ReleaseAddress Operation</seealso>
        public virtual ReleaseAddressResponse ReleaseAddress(ReleaseAddressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReleaseAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReleaseAddressResponseUnmarshaller.Instance;

            return Invoke<ReleaseAddressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReleaseAddress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReleaseAddress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReleaseAddress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseAddress">REST API Reference for ReleaseAddress Operation</seealso>
        public virtual IAsyncResult BeginReleaseAddress(ReleaseAddressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReleaseAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReleaseAddressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReleaseAddress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReleaseAddress.</param>
        /// 
        /// <returns>Returns a  ReleaseAddressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseAddress">REST API Reference for ReleaseAddress Operation</seealso>
        public virtual ReleaseAddressResponse EndReleaseAddress(IAsyncResult asyncResult)
        {
            return EndInvoke<ReleaseAddressResponse>(asyncResult);
        }

        #endregion
        
        #region  ReleaseHosts

        /// <summary>
        /// When you no longer want to use an On-Demand Dedicated Host it can be released. On-Demand
        /// billing is stopped and the host goes into <code>released</code> state. The host ID
        /// of Dedicated Hosts that have been released can no longer be specified in another request,
        /// for example, to modify the host. You must stop or terminate all instances on a host
        /// before it can be released.
        /// 
        ///  
        /// <para>
        /// When Dedicated Hosts are released, it may take some time for them to stop counting
        /// toward your limit and you may receive capacity errors when trying to allocate new
        /// Dedicated Hosts. Wait a few minutes and then try again.
        /// </para>
        ///  
        /// <para>
        /// Released hosts still appear in a <a>DescribeHosts</a> response.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReleaseHosts service method.</param>
        /// 
        /// <returns>The response from the ReleaseHosts service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseHosts">REST API Reference for ReleaseHosts Operation</seealso>
        public virtual ReleaseHostsResponse ReleaseHosts(ReleaseHostsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReleaseHostsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReleaseHostsResponseUnmarshaller.Instance;

            return Invoke<ReleaseHostsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReleaseHosts operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReleaseHosts operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReleaseHosts
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseHosts">REST API Reference for ReleaseHosts Operation</seealso>
        public virtual IAsyncResult BeginReleaseHosts(ReleaseHostsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReleaseHostsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReleaseHostsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReleaseHosts operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReleaseHosts.</param>
        /// 
        /// <returns>Returns a  ReleaseHostsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseHosts">REST API Reference for ReleaseHosts Operation</seealso>
        public virtual ReleaseHostsResponse EndReleaseHosts(IAsyncResult asyncResult)
        {
            return EndInvoke<ReleaseHostsResponse>(asyncResult);
        }

        #endregion
        
        #region  ReleaseIpamPoolAllocation

        /// <summary>
        /// Release an allocation within an IPAM pool. The Region you use should be the IPAM pool
        /// locale. The locale is the Amazon Web Services Region where this IPAM pool is available
        /// for allocations. You can only use this action to release manual allocations. To remove
        /// an allocation for a resource without deleting the resource, set its monitored state
        /// to false using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyIpamResourceCidr.html">ModifyIpamResourceCidr</a>.
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/ipam/release-alloc-ipam.html">Release
        /// an allocation</a> in the <i>Amazon VPC IPAM User Guide</i>. 
        /// 
        ///  <note> 
        /// <para>
        /// All EC2 API actions follow an <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/query-api-troubleshooting.html#eventual-consistency">eventual
        /// consistency</a> model.
        /// </para>
        ///  </note>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReleaseIpamPoolAllocation service method.</param>
        /// 
        /// <returns>The response from the ReleaseIpamPoolAllocation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseIpamPoolAllocation">REST API Reference for ReleaseIpamPoolAllocation Operation</seealso>
        public virtual ReleaseIpamPoolAllocationResponse ReleaseIpamPoolAllocation(ReleaseIpamPoolAllocationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReleaseIpamPoolAllocationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReleaseIpamPoolAllocationResponseUnmarshaller.Instance;

            return Invoke<ReleaseIpamPoolAllocationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReleaseIpamPoolAllocation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReleaseIpamPoolAllocation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReleaseIpamPoolAllocation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseIpamPoolAllocation">REST API Reference for ReleaseIpamPoolAllocation Operation</seealso>
        public virtual IAsyncResult BeginReleaseIpamPoolAllocation(ReleaseIpamPoolAllocationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReleaseIpamPoolAllocationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReleaseIpamPoolAllocationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReleaseIpamPoolAllocation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReleaseIpamPoolAllocation.</param>
        /// 
        /// <returns>Returns a  ReleaseIpamPoolAllocationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReleaseIpamPoolAllocation">REST API Reference for ReleaseIpamPoolAllocation Operation</seealso>
        public virtual ReleaseIpamPoolAllocationResponse EndReleaseIpamPoolAllocation(IAsyncResult asyncResult)
        {
            return EndInvoke<ReleaseIpamPoolAllocationResponse>(asyncResult);
        }

        #endregion
        
        #region  ReplaceIamInstanceProfileAssociation

        /// <summary>
        /// Replaces an IAM instance profile for the specified running instance. You can use this
        /// action to change the IAM instance profile that's associated with an instance without
        /// having to disassociate the existing IAM instance profile first.
        /// 
        ///  
        /// <para>
        /// Use <a>DescribeIamInstanceProfileAssociations</a> to get the association ID.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReplaceIamInstanceProfileAssociation service method.</param>
        /// 
        /// <returns>The response from the ReplaceIamInstanceProfileAssociation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceIamInstanceProfileAssociation">REST API Reference for ReplaceIamInstanceProfileAssociation Operation</seealso>
        public virtual ReplaceIamInstanceProfileAssociationResponse ReplaceIamInstanceProfileAssociation(ReplaceIamInstanceProfileAssociationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceIamInstanceProfileAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceIamInstanceProfileAssociationResponseUnmarshaller.Instance;

            return Invoke<ReplaceIamInstanceProfileAssociationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReplaceIamInstanceProfileAssociation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReplaceIamInstanceProfileAssociation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReplaceIamInstanceProfileAssociation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceIamInstanceProfileAssociation">REST API Reference for ReplaceIamInstanceProfileAssociation Operation</seealso>
        public virtual IAsyncResult BeginReplaceIamInstanceProfileAssociation(ReplaceIamInstanceProfileAssociationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceIamInstanceProfileAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceIamInstanceProfileAssociationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReplaceIamInstanceProfileAssociation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReplaceIamInstanceProfileAssociation.</param>
        /// 
        /// <returns>Returns a  ReplaceIamInstanceProfileAssociationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceIamInstanceProfileAssociation">REST API Reference for ReplaceIamInstanceProfileAssociation Operation</seealso>
        public virtual ReplaceIamInstanceProfileAssociationResponse EndReplaceIamInstanceProfileAssociation(IAsyncResult asyncResult)
        {
            return EndInvoke<ReplaceIamInstanceProfileAssociationResponse>(asyncResult);
        }

        #endregion
        
        #region  ReplaceNetworkAclAssociation

        /// <summary>
        /// Changes which network ACL a subnet is associated with. By default when you create
        /// a subnet, it's automatically associated with the default network ACL. For more information,
        /// see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
        /// ACLs</a> in the <i>Amazon VPC User Guide</i>.
        /// 
        ///  
        /// <para>
        /// This is an idempotent operation.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReplaceNetworkAclAssociation service method.</param>
        /// 
        /// <returns>The response from the ReplaceNetworkAclAssociation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceNetworkAclAssociation">REST API Reference for ReplaceNetworkAclAssociation Operation</seealso>
        public virtual ReplaceNetworkAclAssociationResponse ReplaceNetworkAclAssociation(ReplaceNetworkAclAssociationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceNetworkAclAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceNetworkAclAssociationResponseUnmarshaller.Instance;

            return Invoke<ReplaceNetworkAclAssociationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReplaceNetworkAclAssociation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReplaceNetworkAclAssociation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReplaceNetworkAclAssociation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceNetworkAclAssociation">REST API Reference for ReplaceNetworkAclAssociation Operation</seealso>
        public virtual IAsyncResult BeginReplaceNetworkAclAssociation(ReplaceNetworkAclAssociationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceNetworkAclAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceNetworkAclAssociationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReplaceNetworkAclAssociation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReplaceNetworkAclAssociation.</param>
        /// 
        /// <returns>Returns a  ReplaceNetworkAclAssociationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceNetworkAclAssociation">REST API Reference for ReplaceNetworkAclAssociation Operation</seealso>
        public virtual ReplaceNetworkAclAssociationResponse EndReplaceNetworkAclAssociation(IAsyncResult asyncResult)
        {
            return EndInvoke<ReplaceNetworkAclAssociationResponse>(asyncResult);
        }

        #endregion
        
        #region  ReplaceNetworkAclEntry

        /// <summary>
        /// Replaces an entry (rule) in a network ACL. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html">Network
        /// ACLs</a> in the <i>Amazon VPC User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReplaceNetworkAclEntry service method.</param>
        /// 
        /// <returns>The response from the ReplaceNetworkAclEntry service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceNetworkAclEntry">REST API Reference for ReplaceNetworkAclEntry Operation</seealso>
        public virtual ReplaceNetworkAclEntryResponse ReplaceNetworkAclEntry(ReplaceNetworkAclEntryRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceNetworkAclEntryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceNetworkAclEntryResponseUnmarshaller.Instance;

            return Invoke<ReplaceNetworkAclEntryResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReplaceNetworkAclEntry operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReplaceNetworkAclEntry operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReplaceNetworkAclEntry
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceNetworkAclEntry">REST API Reference for ReplaceNetworkAclEntry Operation</seealso>
        public virtual IAsyncResult BeginReplaceNetworkAclEntry(ReplaceNetworkAclEntryRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceNetworkAclEntryRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceNetworkAclEntryResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReplaceNetworkAclEntry operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReplaceNetworkAclEntry.</param>
        /// 
        /// <returns>Returns a  ReplaceNetworkAclEntryResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceNetworkAclEntry">REST API Reference for ReplaceNetworkAclEntry Operation</seealso>
        public virtual ReplaceNetworkAclEntryResponse EndReplaceNetworkAclEntry(IAsyncResult asyncResult)
        {
            return EndInvoke<ReplaceNetworkAclEntryResponse>(asyncResult);
        }

        #endregion
        
        #region  ReplaceRoute

        /// <summary>
        /// Replaces an existing route within a route table in a VPC.
        /// 
        ///  
        /// <para>
        /// You must specify either a destination CIDR block or a prefix list ID. You must also
        /// specify exactly one of the resources from the parameter list, or reset the local route
        /// to its default target.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
        /// tables</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReplaceRoute service method.</param>
        /// 
        /// <returns>The response from the ReplaceRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceRoute">REST API Reference for ReplaceRoute Operation</seealso>
        public virtual ReplaceRouteResponse ReplaceRoute(ReplaceRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceRouteResponseUnmarshaller.Instance;

            return Invoke<ReplaceRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReplaceRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReplaceRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReplaceRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceRoute">REST API Reference for ReplaceRoute Operation</seealso>
        public virtual IAsyncResult BeginReplaceRoute(ReplaceRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReplaceRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReplaceRoute.</param>
        /// 
        /// <returns>Returns a  ReplaceRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceRoute">REST API Reference for ReplaceRoute Operation</seealso>
        public virtual ReplaceRouteResponse EndReplaceRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<ReplaceRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  ReplaceRouteTableAssociation

        /// <summary>
        /// Changes the route table associated with a given subnet, internet gateway, or virtual
        /// private gateway in a VPC. After the operation completes, the subnet or gateway uses
        /// the routes in the new route table. For more information about route tables, see <a
        /// href="https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html">Route
        /// tables</a> in the <i>Amazon VPC User Guide</i>.
        /// 
        ///  
        /// <para>
        /// You can also use this operation to change which table is the main route table in the
        /// VPC. Specify the main route table's association ID and the route table ID of the new
        /// main route table.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReplaceRouteTableAssociation service method.</param>
        /// 
        /// <returns>The response from the ReplaceRouteTableAssociation service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceRouteTableAssociation">REST API Reference for ReplaceRouteTableAssociation Operation</seealso>
        public virtual ReplaceRouteTableAssociationResponse ReplaceRouteTableAssociation(ReplaceRouteTableAssociationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceRouteTableAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceRouteTableAssociationResponseUnmarshaller.Instance;

            return Invoke<ReplaceRouteTableAssociationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReplaceRouteTableAssociation operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReplaceRouteTableAssociation operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReplaceRouteTableAssociation
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceRouteTableAssociation">REST API Reference for ReplaceRouteTableAssociation Operation</seealso>
        public virtual IAsyncResult BeginReplaceRouteTableAssociation(ReplaceRouteTableAssociationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceRouteTableAssociationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceRouteTableAssociationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReplaceRouteTableAssociation operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReplaceRouteTableAssociation.</param>
        /// 
        /// <returns>Returns a  ReplaceRouteTableAssociationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceRouteTableAssociation">REST API Reference for ReplaceRouteTableAssociation Operation</seealso>
        public virtual ReplaceRouteTableAssociationResponse EndReplaceRouteTableAssociation(IAsyncResult asyncResult)
        {
            return EndInvoke<ReplaceRouteTableAssociationResponse>(asyncResult);
        }

        #endregion
        
        #region  ReplaceTransitGatewayRoute

        /// <summary>
        /// Replaces the specified route in the specified transit gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReplaceTransitGatewayRoute service method.</param>
        /// 
        /// <returns>The response from the ReplaceTransitGatewayRoute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceTransitGatewayRoute">REST API Reference for ReplaceTransitGatewayRoute Operation</seealso>
        public virtual ReplaceTransitGatewayRouteResponse ReplaceTransitGatewayRoute(ReplaceTransitGatewayRouteRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceTransitGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceTransitGatewayRouteResponseUnmarshaller.Instance;

            return Invoke<ReplaceTransitGatewayRouteResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReplaceTransitGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReplaceTransitGatewayRoute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReplaceTransitGatewayRoute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceTransitGatewayRoute">REST API Reference for ReplaceTransitGatewayRoute Operation</seealso>
        public virtual IAsyncResult BeginReplaceTransitGatewayRoute(ReplaceTransitGatewayRouteRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceTransitGatewayRouteRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceTransitGatewayRouteResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReplaceTransitGatewayRoute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReplaceTransitGatewayRoute.</param>
        /// 
        /// <returns>Returns a  ReplaceTransitGatewayRouteResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceTransitGatewayRoute">REST API Reference for ReplaceTransitGatewayRoute Operation</seealso>
        public virtual ReplaceTransitGatewayRouteResponse EndReplaceTransitGatewayRoute(IAsyncResult asyncResult)
        {
            return EndInvoke<ReplaceTransitGatewayRouteResponse>(asyncResult);
        }

        #endregion
        
        #region  ReplaceVpnTunnel

        /// <summary>
        /// Trigger replacement of specified VPN tunnel.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReplaceVpnTunnel service method.</param>
        /// 
        /// <returns>The response from the ReplaceVpnTunnel service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceVpnTunnel">REST API Reference for ReplaceVpnTunnel Operation</seealso>
        public virtual ReplaceVpnTunnelResponse ReplaceVpnTunnel(ReplaceVpnTunnelRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceVpnTunnelRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceVpnTunnelResponseUnmarshaller.Instance;

            return Invoke<ReplaceVpnTunnelResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReplaceVpnTunnel operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReplaceVpnTunnel operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReplaceVpnTunnel
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceVpnTunnel">REST API Reference for ReplaceVpnTunnel Operation</seealso>
        public virtual IAsyncResult BeginReplaceVpnTunnel(ReplaceVpnTunnelRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReplaceVpnTunnelRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReplaceVpnTunnelResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReplaceVpnTunnel operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReplaceVpnTunnel.</param>
        /// 
        /// <returns>Returns a  ReplaceVpnTunnelResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReplaceVpnTunnel">REST API Reference for ReplaceVpnTunnel Operation</seealso>
        public virtual ReplaceVpnTunnelResponse EndReplaceVpnTunnel(IAsyncResult asyncResult)
        {
            return EndInvoke<ReplaceVpnTunnelResponse>(asyncResult);
        }

        #endregion
        
        #region  ReportInstanceStatus

        /// <summary>
        /// Submits feedback about the status of an instance. The instance must be in the <code>running</code>
        /// state. If your experience with the instance differs from the instance status returned
        /// by <a>DescribeInstanceStatus</a>, use <a>ReportInstanceStatus</a> to report your experience
        /// with the instance. Amazon EC2 collects this information to improve the accuracy of
        /// status checks.
        /// 
        ///  
        /// <para>
        /// Use of this action does not change the value returned by <a>DescribeInstanceStatus</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ReportInstanceStatus service method.</param>
        /// 
        /// <returns>The response from the ReportInstanceStatus service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReportInstanceStatus">REST API Reference for ReportInstanceStatus Operation</seealso>
        public virtual ReportInstanceStatusResponse ReportInstanceStatus(ReportInstanceStatusRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReportInstanceStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReportInstanceStatusResponseUnmarshaller.Instance;

            return Invoke<ReportInstanceStatusResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ReportInstanceStatus operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ReportInstanceStatus operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndReportInstanceStatus
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReportInstanceStatus">REST API Reference for ReportInstanceStatus Operation</seealso>
        public virtual IAsyncResult BeginReportInstanceStatus(ReportInstanceStatusRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ReportInstanceStatusRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ReportInstanceStatusResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ReportInstanceStatus operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginReportInstanceStatus.</param>
        /// 
        /// <returns>Returns a  ReportInstanceStatusResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ReportInstanceStatus">REST API Reference for ReportInstanceStatus Operation</seealso>
        public virtual ReportInstanceStatusResponse EndReportInstanceStatus(IAsyncResult asyncResult)
        {
            return EndInvoke<ReportInstanceStatusResponse>(asyncResult);
        }

        #endregion
        
        #region  RequestSpotFleet

        /// <summary>
        /// Creates a Spot Fleet request.
        /// 
        ///  
        /// <para>
        /// The Spot Fleet request specifies the total target capacity and the On-Demand target
        /// capacity. Amazon EC2 calculates the difference between the total capacity and On-Demand
        /// capacity, and launches the difference as Spot capacity.
        /// </para>
        ///  
        /// <para>
        /// You can submit a single request that includes multiple launch specifications that
        /// vary by instance type, AMI, Availability Zone, or subnet.
        /// </para>
        ///  
        /// <para>
        /// By default, the Spot Fleet requests Spot Instances in the Spot Instance pool where
        /// the price per unit is the lowest. Each launch specification can include its own instance
        /// weighting that reflects the value of the instance type to your application workload.
        /// </para>
        ///  
        /// <para>
        /// Alternatively, you can specify that the Spot Fleet distribute the target capacity
        /// across the Spot pools included in its launch specifications. By ensuring that the
        /// Spot Instances in your Spot Fleet are in different Spot pools, you can improve the
        /// availability of your fleet.
        /// </para>
        ///  
        /// <para>
        /// You can specify tags for the Spot Fleet request and instances launched by the fleet.
        /// You cannot tag other resource types in a Spot Fleet request because only the <code>spot-fleet-request</code>
        /// and <code>instance</code> resource types are supported.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-fleet-requests.html">Spot
        /// Fleet requests</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  <important> 
        /// <para>
        /// We strongly discourage using the RequestSpotFleet API because it is a legacy API with
        /// no planned investment. For options for requesting Spot Instances, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-best-practices.html#which-spot-request-method-to-use">Which
        /// is the best Spot request method to use?</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  </important>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RequestSpotFleet service method.</param>
        /// 
        /// <returns>The response from the RequestSpotFleet service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RequestSpotFleet">REST API Reference for RequestSpotFleet Operation</seealso>
        public virtual RequestSpotFleetResponse RequestSpotFleet(RequestSpotFleetRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RequestSpotFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RequestSpotFleetResponseUnmarshaller.Instance;

            return Invoke<RequestSpotFleetResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RequestSpotFleet operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RequestSpotFleet operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRequestSpotFleet
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RequestSpotFleet">REST API Reference for RequestSpotFleet Operation</seealso>
        public virtual IAsyncResult BeginRequestSpotFleet(RequestSpotFleetRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RequestSpotFleetRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RequestSpotFleetResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RequestSpotFleet operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRequestSpotFleet.</param>
        /// 
        /// <returns>Returns a  RequestSpotFleetResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RequestSpotFleet">REST API Reference for RequestSpotFleet Operation</seealso>
        public virtual RequestSpotFleetResponse EndRequestSpotFleet(IAsyncResult asyncResult)
        {
            return EndInvoke<RequestSpotFleetResponse>(asyncResult);
        }

        #endregion
        
        #region  RequestSpotInstances

        /// <summary>
        /// Creates a Spot Instance request.
        /// 
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html">Spot
        /// Instance requests</a> in the <i>Amazon EC2 User Guide for Linux Instances</i>.
        /// </para>
        ///  <important> 
        /// <para>
        /// We strongly discourage using the RequestSpotInstances API because it is a legacy API
        /// with no planned investment. For options for requesting Spot Instances, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-best-practices.html#which-spot-request-method-to-use">Which
        /// is the best Spot request method to use?</a> in the <i>Amazon EC2 User Guide for Linux
        /// Instances</i>.
        /// </para>
        ///  </important>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RequestSpotInstances service method.</param>
        /// 
        /// <returns>The response from the RequestSpotInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RequestSpotInstances">REST API Reference for RequestSpotInstances Operation</seealso>
        public virtual RequestSpotInstancesResponse RequestSpotInstances(RequestSpotInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RequestSpotInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RequestSpotInstancesResponseUnmarshaller.Instance;

            return Invoke<RequestSpotInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RequestSpotInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RequestSpotInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRequestSpotInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RequestSpotInstances">REST API Reference for RequestSpotInstances Operation</seealso>
        public virtual IAsyncResult BeginRequestSpotInstances(RequestSpotInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RequestSpotInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RequestSpotInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RequestSpotInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRequestSpotInstances.</param>
        /// 
        /// <returns>Returns a  RequestSpotInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RequestSpotInstances">REST API Reference for RequestSpotInstances Operation</seealso>
        public virtual RequestSpotInstancesResponse EndRequestSpotInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<RequestSpotInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  ResetAddressAttribute

        /// <summary>
        /// Resets the attribute of the specified IP address. For requirements, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html#Using_Elastic_Addressing_Reverse_DNS">Using
        /// reverse DNS for email applications</a>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ResetAddressAttribute service method.</param>
        /// 
        /// <returns>The response from the ResetAddressAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetAddressAttribute">REST API Reference for ResetAddressAttribute Operation</seealso>
        public virtual ResetAddressAttributeResponse ResetAddressAttribute(ResetAddressAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetAddressAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetAddressAttributeResponseUnmarshaller.Instance;

            return Invoke<ResetAddressAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ResetAddressAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ResetAddressAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetAddressAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetAddressAttribute">REST API Reference for ResetAddressAttribute Operation</seealso>
        public virtual IAsyncResult BeginResetAddressAttribute(ResetAddressAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetAddressAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetAddressAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ResetAddressAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginResetAddressAttribute.</param>
        /// 
        /// <returns>Returns a  ResetAddressAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetAddressAttribute">REST API Reference for ResetAddressAttribute Operation</seealso>
        public virtual ResetAddressAttributeResponse EndResetAddressAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ResetAddressAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ResetEbsDefaultKmsKeyId

        /// <summary>
        /// Resets the default KMS key for EBS encryption for your account in this Region to the
        /// Amazon Web Services managed KMS key for EBS.
        /// 
        ///  
        /// <para>
        /// After resetting the default KMS key to the Amazon Web Services managed KMS key, you
        /// can continue to encrypt by a customer managed KMS key by specifying it when you create
        /// the volume. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html">Amazon
        /// EBS encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ResetEbsDefaultKmsKeyId service method.</param>
        /// 
        /// <returns>The response from the ResetEbsDefaultKmsKeyId service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetEbsDefaultKmsKeyId">REST API Reference for ResetEbsDefaultKmsKeyId Operation</seealso>
        public virtual ResetEbsDefaultKmsKeyIdResponse ResetEbsDefaultKmsKeyId(ResetEbsDefaultKmsKeyIdRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetEbsDefaultKmsKeyIdRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetEbsDefaultKmsKeyIdResponseUnmarshaller.Instance;

            return Invoke<ResetEbsDefaultKmsKeyIdResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ResetEbsDefaultKmsKeyId operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ResetEbsDefaultKmsKeyId operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetEbsDefaultKmsKeyId
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetEbsDefaultKmsKeyId">REST API Reference for ResetEbsDefaultKmsKeyId Operation</seealso>
        public virtual IAsyncResult BeginResetEbsDefaultKmsKeyId(ResetEbsDefaultKmsKeyIdRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetEbsDefaultKmsKeyIdRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetEbsDefaultKmsKeyIdResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ResetEbsDefaultKmsKeyId operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginResetEbsDefaultKmsKeyId.</param>
        /// 
        /// <returns>Returns a  ResetEbsDefaultKmsKeyIdResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetEbsDefaultKmsKeyId">REST API Reference for ResetEbsDefaultKmsKeyId Operation</seealso>
        public virtual ResetEbsDefaultKmsKeyIdResponse EndResetEbsDefaultKmsKeyId(IAsyncResult asyncResult)
        {
            return EndInvoke<ResetEbsDefaultKmsKeyIdResponse>(asyncResult);
        }

        #endregion
        
        #region  ResetFpgaImageAttribute

        /// <summary>
        /// Resets the specified attribute of the specified Amazon FPGA Image (AFI) to its default
        /// value. You can only reset the load permission attribute.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ResetFpgaImageAttribute service method.</param>
        /// 
        /// <returns>The response from the ResetFpgaImageAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetFpgaImageAttribute">REST API Reference for ResetFpgaImageAttribute Operation</seealso>
        public virtual ResetFpgaImageAttributeResponse ResetFpgaImageAttribute(ResetFpgaImageAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetFpgaImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetFpgaImageAttributeResponseUnmarshaller.Instance;

            return Invoke<ResetFpgaImageAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ResetFpgaImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ResetFpgaImageAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetFpgaImageAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetFpgaImageAttribute">REST API Reference for ResetFpgaImageAttribute Operation</seealso>
        public virtual IAsyncResult BeginResetFpgaImageAttribute(ResetFpgaImageAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetFpgaImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetFpgaImageAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ResetFpgaImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginResetFpgaImageAttribute.</param>
        /// 
        /// <returns>Returns a  ResetFpgaImageAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetFpgaImageAttribute">REST API Reference for ResetFpgaImageAttribute Operation</seealso>
        public virtual ResetFpgaImageAttributeResponse EndResetFpgaImageAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ResetFpgaImageAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ResetImageAttribute

        /// <summary>
        /// Resets an attribute of an AMI to its default value.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ResetImageAttribute service method.</param>
        /// 
        /// <returns>The response from the ResetImageAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetImageAttribute">REST API Reference for ResetImageAttribute Operation</seealso>
        public virtual ResetImageAttributeResponse ResetImageAttribute(ResetImageAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetImageAttributeResponseUnmarshaller.Instance;

            return Invoke<ResetImageAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ResetImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ResetImageAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetImageAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetImageAttribute">REST API Reference for ResetImageAttribute Operation</seealso>
        public virtual IAsyncResult BeginResetImageAttribute(ResetImageAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetImageAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetImageAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ResetImageAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginResetImageAttribute.</param>
        /// 
        /// <returns>Returns a  ResetImageAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetImageAttribute">REST API Reference for ResetImageAttribute Operation</seealso>
        public virtual ResetImageAttributeResponse EndResetImageAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ResetImageAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ResetInstanceAttribute

        /// <summary>
        /// Resets an attribute of an instance to its default value. To reset the <code>kernel</code>
        /// or <code>ramdisk</code>, the instance must be in a stopped state. To reset the <code>sourceDestCheck</code>,
        /// the instance can be either running or stopped.
        /// 
        ///  
        /// <para>
        /// The <code>sourceDestCheck</code> attribute controls whether source/destination checking
        /// is enabled. The default value is <code>true</code>, which means checking is enabled.
        /// This value must be <code>false</code> for a NAT instance to perform NAT. For more
        /// information, see <a href="https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_NAT_Instance.html">NAT
        /// Instances</a> in the <i>Amazon VPC User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ResetInstanceAttribute service method.</param>
        /// 
        /// <returns>The response from the ResetInstanceAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetInstanceAttribute">REST API Reference for ResetInstanceAttribute Operation</seealso>
        public virtual ResetInstanceAttributeResponse ResetInstanceAttribute(ResetInstanceAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetInstanceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetInstanceAttributeResponseUnmarshaller.Instance;

            return Invoke<ResetInstanceAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ResetInstanceAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ResetInstanceAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetInstanceAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetInstanceAttribute">REST API Reference for ResetInstanceAttribute Operation</seealso>
        public virtual IAsyncResult BeginResetInstanceAttribute(ResetInstanceAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetInstanceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetInstanceAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ResetInstanceAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginResetInstanceAttribute.</param>
        /// 
        /// <returns>Returns a  ResetInstanceAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetInstanceAttribute">REST API Reference for ResetInstanceAttribute Operation</seealso>
        public virtual ResetInstanceAttributeResponse EndResetInstanceAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ResetInstanceAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ResetNetworkInterfaceAttribute

        /// <summary>
        /// Resets a network interface attribute. You can specify only one attribute at a time.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ResetNetworkInterfaceAttribute service method.</param>
        /// 
        /// <returns>The response from the ResetNetworkInterfaceAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetNetworkInterfaceAttribute">REST API Reference for ResetNetworkInterfaceAttribute Operation</seealso>
        public virtual ResetNetworkInterfaceAttributeResponse ResetNetworkInterfaceAttribute(ResetNetworkInterfaceAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetNetworkInterfaceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetNetworkInterfaceAttributeResponseUnmarshaller.Instance;

            return Invoke<ResetNetworkInterfaceAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ResetNetworkInterfaceAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ResetNetworkInterfaceAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetNetworkInterfaceAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetNetworkInterfaceAttribute">REST API Reference for ResetNetworkInterfaceAttribute Operation</seealso>
        public virtual IAsyncResult BeginResetNetworkInterfaceAttribute(ResetNetworkInterfaceAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetNetworkInterfaceAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetNetworkInterfaceAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ResetNetworkInterfaceAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginResetNetworkInterfaceAttribute.</param>
        /// 
        /// <returns>Returns a  ResetNetworkInterfaceAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetNetworkInterfaceAttribute">REST API Reference for ResetNetworkInterfaceAttribute Operation</seealso>
        public virtual ResetNetworkInterfaceAttributeResponse EndResetNetworkInterfaceAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ResetNetworkInterfaceAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  ResetSnapshotAttribute

        /// <summary>
        /// Resets permission settings for the specified snapshot.
        /// 
        ///  
        /// <para>
        /// For more information about modifying snapshot permissions, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-modifying-snapshot-permissions.html">Share
        /// a snapshot</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the ResetSnapshotAttribute service method.</param>
        /// 
        /// <returns>The response from the ResetSnapshotAttribute service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetSnapshotAttribute">REST API Reference for ResetSnapshotAttribute Operation</seealso>
        public virtual ResetSnapshotAttributeResponse ResetSnapshotAttribute(ResetSnapshotAttributeRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetSnapshotAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetSnapshotAttributeResponseUnmarshaller.Instance;

            return Invoke<ResetSnapshotAttributeResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the ResetSnapshotAttribute operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the ResetSnapshotAttribute operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetSnapshotAttribute
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetSnapshotAttribute">REST API Reference for ResetSnapshotAttribute Operation</seealso>
        public virtual IAsyncResult BeginResetSnapshotAttribute(ResetSnapshotAttributeRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = ResetSnapshotAttributeRequestMarshaller.Instance;
            options.ResponseUnmarshaller = ResetSnapshotAttributeResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  ResetSnapshotAttribute operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginResetSnapshotAttribute.</param>
        /// 
        /// <returns>Returns a  ResetSnapshotAttributeResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/ResetSnapshotAttribute">REST API Reference for ResetSnapshotAttribute Operation</seealso>
        public virtual ResetSnapshotAttributeResponse EndResetSnapshotAttribute(IAsyncResult asyncResult)
        {
            return EndInvoke<ResetSnapshotAttributeResponse>(asyncResult);
        }

        #endregion
        
        #region  RestoreAddressToClassic

        /// <summary>
        /// <note> 
        /// <para>
        /// This action is deprecated.
        /// </para>
        ///  </note> 
        /// <para>
        /// Restores an Elastic IP address that was previously moved to the EC2-VPC platform back
        /// to the EC2-Classic platform. You cannot move an Elastic IP address that was originally
        /// allocated for use in EC2-VPC. The Elastic IP address must not be associated with an
        /// instance or network interface.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RestoreAddressToClassic service method.</param>
        /// 
        /// <returns>The response from the RestoreAddressToClassic service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreAddressToClassic">REST API Reference for RestoreAddressToClassic Operation</seealso>
        public virtual RestoreAddressToClassicResponse RestoreAddressToClassic(RestoreAddressToClassicRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreAddressToClassicRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreAddressToClassicResponseUnmarshaller.Instance;

            return Invoke<RestoreAddressToClassicResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RestoreAddressToClassic operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RestoreAddressToClassic operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRestoreAddressToClassic
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreAddressToClassic">REST API Reference for RestoreAddressToClassic Operation</seealso>
        public virtual IAsyncResult BeginRestoreAddressToClassic(RestoreAddressToClassicRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreAddressToClassicRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreAddressToClassicResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RestoreAddressToClassic operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRestoreAddressToClassic.</param>
        /// 
        /// <returns>Returns a  RestoreAddressToClassicResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreAddressToClassic">REST API Reference for RestoreAddressToClassic Operation</seealso>
        public virtual RestoreAddressToClassicResponse EndRestoreAddressToClassic(IAsyncResult asyncResult)
        {
            return EndInvoke<RestoreAddressToClassicResponse>(asyncResult);
        }

        #endregion
        
        #region  RestoreImageFromRecycleBin

        /// <summary>
        /// Restores an AMI from the Recycle Bin. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin.html">Recycle
        /// Bin</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RestoreImageFromRecycleBin service method.</param>
        /// 
        /// <returns>The response from the RestoreImageFromRecycleBin service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreImageFromRecycleBin">REST API Reference for RestoreImageFromRecycleBin Operation</seealso>
        public virtual RestoreImageFromRecycleBinResponse RestoreImageFromRecycleBin(RestoreImageFromRecycleBinRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreImageFromRecycleBinRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreImageFromRecycleBinResponseUnmarshaller.Instance;

            return Invoke<RestoreImageFromRecycleBinResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RestoreImageFromRecycleBin operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RestoreImageFromRecycleBin operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRestoreImageFromRecycleBin
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreImageFromRecycleBin">REST API Reference for RestoreImageFromRecycleBin Operation</seealso>
        public virtual IAsyncResult BeginRestoreImageFromRecycleBin(RestoreImageFromRecycleBinRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreImageFromRecycleBinRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreImageFromRecycleBinResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RestoreImageFromRecycleBin operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRestoreImageFromRecycleBin.</param>
        /// 
        /// <returns>Returns a  RestoreImageFromRecycleBinResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreImageFromRecycleBin">REST API Reference for RestoreImageFromRecycleBin Operation</seealso>
        public virtual RestoreImageFromRecycleBinResponse EndRestoreImageFromRecycleBin(IAsyncResult asyncResult)
        {
            return EndInvoke<RestoreImageFromRecycleBinResponse>(asyncResult);
        }

        #endregion
        
        #region  RestoreManagedPrefixListVersion

        /// <summary>
        /// Restores the entries from a previous version of a managed prefix list to a new version
        /// of the prefix list.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RestoreManagedPrefixListVersion service method.</param>
        /// 
        /// <returns>The response from the RestoreManagedPrefixListVersion service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreManagedPrefixListVersion">REST API Reference for RestoreManagedPrefixListVersion Operation</seealso>
        public virtual RestoreManagedPrefixListVersionResponse RestoreManagedPrefixListVersion(RestoreManagedPrefixListVersionRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreManagedPrefixListVersionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreManagedPrefixListVersionResponseUnmarshaller.Instance;

            return Invoke<RestoreManagedPrefixListVersionResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RestoreManagedPrefixListVersion operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RestoreManagedPrefixListVersion operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRestoreManagedPrefixListVersion
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreManagedPrefixListVersion">REST API Reference for RestoreManagedPrefixListVersion Operation</seealso>
        public virtual IAsyncResult BeginRestoreManagedPrefixListVersion(RestoreManagedPrefixListVersionRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreManagedPrefixListVersionRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreManagedPrefixListVersionResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RestoreManagedPrefixListVersion operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRestoreManagedPrefixListVersion.</param>
        /// 
        /// <returns>Returns a  RestoreManagedPrefixListVersionResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreManagedPrefixListVersion">REST API Reference for RestoreManagedPrefixListVersion Operation</seealso>
        public virtual RestoreManagedPrefixListVersionResponse EndRestoreManagedPrefixListVersion(IAsyncResult asyncResult)
        {
            return EndInvoke<RestoreManagedPrefixListVersionResponse>(asyncResult);
        }

        #endregion
        
        #region  RestoreSnapshotFromRecycleBin

        /// <summary>
        /// Restores a snapshot from the Recycle Bin. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin-working-with-snaps.html#recycle-bin-restore-snaps">Restore
        /// snapshots from the Recycle Bin</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RestoreSnapshotFromRecycleBin service method.</param>
        /// 
        /// <returns>The response from the RestoreSnapshotFromRecycleBin service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreSnapshotFromRecycleBin">REST API Reference for RestoreSnapshotFromRecycleBin Operation</seealso>
        public virtual RestoreSnapshotFromRecycleBinResponse RestoreSnapshotFromRecycleBin(RestoreSnapshotFromRecycleBinRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreSnapshotFromRecycleBinRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreSnapshotFromRecycleBinResponseUnmarshaller.Instance;

            return Invoke<RestoreSnapshotFromRecycleBinResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RestoreSnapshotFromRecycleBin operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RestoreSnapshotFromRecycleBin operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRestoreSnapshotFromRecycleBin
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreSnapshotFromRecycleBin">REST API Reference for RestoreSnapshotFromRecycleBin Operation</seealso>
        public virtual IAsyncResult BeginRestoreSnapshotFromRecycleBin(RestoreSnapshotFromRecycleBinRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreSnapshotFromRecycleBinRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreSnapshotFromRecycleBinResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RestoreSnapshotFromRecycleBin operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRestoreSnapshotFromRecycleBin.</param>
        /// 
        /// <returns>Returns a  RestoreSnapshotFromRecycleBinResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreSnapshotFromRecycleBin">REST API Reference for RestoreSnapshotFromRecycleBin Operation</seealso>
        public virtual RestoreSnapshotFromRecycleBinResponse EndRestoreSnapshotFromRecycleBin(IAsyncResult asyncResult)
        {
            return EndInvoke<RestoreSnapshotFromRecycleBinResponse>(asyncResult);
        }

        #endregion
        
        #region  RestoreSnapshotTier

        /// <summary>
        /// Restores an archived Amazon EBS snapshot for use temporarily or permanently, or modifies
        /// the restore period or restore type for a snapshot that was previously temporarily
        /// restored.
        /// 
        ///  
        /// <para>
        /// For more information see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-snapshot-archiving.html#restore-archived-snapshot">
        /// Restore an archived snapshot</a> and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-snapshot-archiving.html#modify-temp-restore-period">
        /// modify the restore period or restore type for a temporarily restored snapshot</a>
        /// in the <i>Amazon Elastic Compute Cloud User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RestoreSnapshotTier service method.</param>
        /// 
        /// <returns>The response from the RestoreSnapshotTier service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreSnapshotTier">REST API Reference for RestoreSnapshotTier Operation</seealso>
        public virtual RestoreSnapshotTierResponse RestoreSnapshotTier(RestoreSnapshotTierRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreSnapshotTierRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreSnapshotTierResponseUnmarshaller.Instance;

            return Invoke<RestoreSnapshotTierResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RestoreSnapshotTier operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RestoreSnapshotTier operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRestoreSnapshotTier
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreSnapshotTier">REST API Reference for RestoreSnapshotTier Operation</seealso>
        public virtual IAsyncResult BeginRestoreSnapshotTier(RestoreSnapshotTierRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RestoreSnapshotTierRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RestoreSnapshotTierResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RestoreSnapshotTier operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRestoreSnapshotTier.</param>
        /// 
        /// <returns>Returns a  RestoreSnapshotTierResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RestoreSnapshotTier">REST API Reference for RestoreSnapshotTier Operation</seealso>
        public virtual RestoreSnapshotTierResponse EndRestoreSnapshotTier(IAsyncResult asyncResult)
        {
            return EndInvoke<RestoreSnapshotTierResponse>(asyncResult);
        }

        #endregion
        
        #region  RevokeClientVpnIngress

        /// <summary>
        /// Removes an ingress authorization rule from a Client VPN endpoint.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RevokeClientVpnIngress service method.</param>
        /// 
        /// <returns>The response from the RevokeClientVpnIngress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeClientVpnIngress">REST API Reference for RevokeClientVpnIngress Operation</seealso>
        public virtual RevokeClientVpnIngressResponse RevokeClientVpnIngress(RevokeClientVpnIngressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RevokeClientVpnIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RevokeClientVpnIngressResponseUnmarshaller.Instance;

            return Invoke<RevokeClientVpnIngressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RevokeClientVpnIngress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RevokeClientVpnIngress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRevokeClientVpnIngress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeClientVpnIngress">REST API Reference for RevokeClientVpnIngress Operation</seealso>
        public virtual IAsyncResult BeginRevokeClientVpnIngress(RevokeClientVpnIngressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RevokeClientVpnIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RevokeClientVpnIngressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RevokeClientVpnIngress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRevokeClientVpnIngress.</param>
        /// 
        /// <returns>Returns a  RevokeClientVpnIngressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeClientVpnIngress">REST API Reference for RevokeClientVpnIngress Operation</seealso>
        public virtual RevokeClientVpnIngressResponse EndRevokeClientVpnIngress(IAsyncResult asyncResult)
        {
            return EndInvoke<RevokeClientVpnIngressResponse>(asyncResult);
        }

        #endregion
        
        #region  RevokeSecurityGroupEgress

        /// <summary>
        /// Removes the specified outbound (egress) rules from the specified security group.
        /// 
        ///  
        /// <para>
        /// You can specify rules using either rule IDs or security group rule properties. If
        /// you use rule properties, the values that you specify (for example, ports) must match
        /// the existing rule's values exactly. Each rule has a protocol, from and to ports, and
        /// destination (CIDR range, security group, or prefix list). For the TCP and UDP protocols,
        /// you must also specify the destination port or range of ports. For the ICMP protocol,
        /// you must also specify the ICMP type and code. If the security group rule has a description,
        /// you do not need to specify the description to revoke the rule.
        /// </para>
        ///  
        /// <para>
        /// For a default VPC, if the values you specify do not match the existing rule's values,
        /// no error is returned, and the output describes the security group rules that were
        /// not revoked.
        /// </para>
        ///  
        /// <para>
        /// Amazon Web Services recommends that you describe the security group to verify that
        /// the rules were removed.
        /// </para>
        ///  
        /// <para>
        /// Rule changes are propagated to instances within the security group as quickly as possible.
        /// However, a small delay might occur.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RevokeSecurityGroupEgress service method.</param>
        /// 
        /// <returns>The response from the RevokeSecurityGroupEgress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeSecurityGroupEgress">REST API Reference for RevokeSecurityGroupEgress Operation</seealso>
        public virtual RevokeSecurityGroupEgressResponse RevokeSecurityGroupEgress(RevokeSecurityGroupEgressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RevokeSecurityGroupEgressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RevokeSecurityGroupEgressResponseUnmarshaller.Instance;

            return Invoke<RevokeSecurityGroupEgressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RevokeSecurityGroupEgress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RevokeSecurityGroupEgress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRevokeSecurityGroupEgress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeSecurityGroupEgress">REST API Reference for RevokeSecurityGroupEgress Operation</seealso>
        public virtual IAsyncResult BeginRevokeSecurityGroupEgress(RevokeSecurityGroupEgressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RevokeSecurityGroupEgressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RevokeSecurityGroupEgressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RevokeSecurityGroupEgress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRevokeSecurityGroupEgress.</param>
        /// 
        /// <returns>Returns a  RevokeSecurityGroupEgressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeSecurityGroupEgress">REST API Reference for RevokeSecurityGroupEgress Operation</seealso>
        public virtual RevokeSecurityGroupEgressResponse EndRevokeSecurityGroupEgress(IAsyncResult asyncResult)
        {
            return EndInvoke<RevokeSecurityGroupEgressResponse>(asyncResult);
        }

        #endregion
        
        #region  RevokeSecurityGroupIngress

        /// <summary>
        /// Removes the specified inbound (ingress) rules from a security group.
        /// 
        ///  
        /// <para>
        /// You can specify rules using either rule IDs or security group rule properties. If
        /// you use rule properties, the values that you specify (for example, ports) must match
        /// the existing rule's values exactly. Each rule has a protocol, from and to ports, and
        /// source (CIDR range, security group, or prefix list). For the TCP and UDP protocols,
        /// you must also specify the destination port or range of ports. For the ICMP protocol,
        /// you must also specify the ICMP type and code. If the security group rule has a description,
        /// you do not need to specify the description to revoke the rule.
        /// </para>
        ///  
        /// <para>
        /// For a default VPC, if the values you specify do not match the existing rule's values,
        /// no error is returned, and the output describes the security group rules that were
        /// not revoked.
        /// </para>
        ///  
        /// <para>
        /// Amazon Web Services recommends that you describe the security group to verify that
        /// the rules were removed.
        /// </para>
        ///  
        /// <para>
        /// Rule changes are propagated to instances within the security group as quickly as possible.
        /// However, a small delay might occur.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RevokeSecurityGroupIngress service method.</param>
        /// 
        /// <returns>The response from the RevokeSecurityGroupIngress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeSecurityGroupIngress">REST API Reference for RevokeSecurityGroupIngress Operation</seealso>
        public virtual RevokeSecurityGroupIngressResponse RevokeSecurityGroupIngress(RevokeSecurityGroupIngressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RevokeSecurityGroupIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RevokeSecurityGroupIngressResponseUnmarshaller.Instance;

            return Invoke<RevokeSecurityGroupIngressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RevokeSecurityGroupIngress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RevokeSecurityGroupIngress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRevokeSecurityGroupIngress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeSecurityGroupIngress">REST API Reference for RevokeSecurityGroupIngress Operation</seealso>
        public virtual IAsyncResult BeginRevokeSecurityGroupIngress(RevokeSecurityGroupIngressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RevokeSecurityGroupIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RevokeSecurityGroupIngressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RevokeSecurityGroupIngress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRevokeSecurityGroupIngress.</param>
        /// 
        /// <returns>Returns a  RevokeSecurityGroupIngressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RevokeSecurityGroupIngress">REST API Reference for RevokeSecurityGroupIngress Operation</seealso>
        public virtual RevokeSecurityGroupIngressResponse EndRevokeSecurityGroupIngress(IAsyncResult asyncResult)
        {
            return EndInvoke<RevokeSecurityGroupIngressResponse>(asyncResult);
        }

        #endregion
        
        #region  RunInstances

        /// <summary>
        /// Launches the specified number of instances using an AMI for which you have permissions.
        /// 
        ///  
        /// <para>
        /// You can specify a number of options, or leave the default options. The following rules
        /// apply:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        /// If you don't specify a subnet ID, we choose a default subnet from your default VPC
        /// for you. If you don't have a default VPC, you must specify a subnet ID in the request.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// All instances have a network interface with a primary private IPv4 address. If you
        /// don't specify this address, we choose one from the IPv4 range of your subnet.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Not all instance types support IPv6 addresses. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html">Instance
        /// types</a>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// If you don't specify a security group ID, we use the default security group. For more
        /// information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html">Security
        /// groups</a>.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// If any of the AMIs have a product code attached for which the user has not subscribed,
        /// the request fails.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// You can create a <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">launch
        /// template</a>, which is a resource that contains the parameters to launch an instance.
        /// When you launch an instance using <a>RunInstances</a>, you can specify the launch
        /// template instead of specifying the launch parameters.
        /// </para>
        ///  
        /// <para>
        /// To ensure faster instance launches, break up large requests into smaller batches.
        /// For example, create five separate launch requests for 100 instances each instead of
        /// one launch request for 500 instances.
        /// </para>
        ///  
        /// <para>
        /// An instance is ready for you to use when it's in the <code>running</code> state. You
        /// can check the state of your instance using <a>DescribeInstances</a>. You can tag instances
        /// and EBS volumes during launch, after launch, or both. For more information, see <a>CreateTags</a>
        /// and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html">Tagging
        /// your Amazon EC2 resources</a>.
        /// </para>
        ///  
        /// <para>
        /// Linux instances have access to the public key of the key pair at boot. You can use
        /// this key to provide secure access to the instance. Amazon EC2 public images use this
        /// feature to provide secure access without passwords. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html">Key
        /// pairs</a>.
        /// </para>
        ///  
        /// <para>
        /// For troubleshooting, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_InstanceStraightToTerminated.html">What
        /// to do if an instance immediately terminates</a>, and <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html">Troubleshooting
        /// connecting to your instance</a>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RunInstances service method.</param>
        /// 
        /// <returns>The response from the RunInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RunInstances">REST API Reference for RunInstances Operation</seealso>
        public virtual RunInstancesResponse RunInstances(RunInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RunInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RunInstancesResponseUnmarshaller.Instance;

            return Invoke<RunInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RunInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RunInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRunInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RunInstances">REST API Reference for RunInstances Operation</seealso>
        public virtual IAsyncResult BeginRunInstances(RunInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RunInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RunInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RunInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRunInstances.</param>
        /// 
        /// <returns>Returns a  RunInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RunInstances">REST API Reference for RunInstances Operation</seealso>
        public virtual RunInstancesResponse EndRunInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<RunInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  RunScheduledInstances

        /// <summary>
        /// Launches the specified Scheduled Instances.
        /// 
        ///  
        /// <para>
        /// Before you can launch a Scheduled Instance, you must purchase it and obtain an identifier
        /// using <a>PurchaseScheduledInstances</a>.
        /// </para>
        ///  
        /// <para>
        /// You must launch a Scheduled Instance during its scheduled time period. You can't stop
        /// or reboot a Scheduled Instance, but you can terminate it as needed. If you terminate
        /// a Scheduled Instance before the current scheduled time period ends, you can launch
        /// it again after a few minutes. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-scheduled-instances.html">Scheduled
        /// Instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the RunScheduledInstances service method.</param>
        /// 
        /// <returns>The response from the RunScheduledInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RunScheduledInstances">REST API Reference for RunScheduledInstances Operation</seealso>
        public virtual RunScheduledInstancesResponse RunScheduledInstances(RunScheduledInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RunScheduledInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RunScheduledInstancesResponseUnmarshaller.Instance;

            return Invoke<RunScheduledInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the RunScheduledInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the RunScheduledInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRunScheduledInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RunScheduledInstances">REST API Reference for RunScheduledInstances Operation</seealso>
        public virtual IAsyncResult BeginRunScheduledInstances(RunScheduledInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = RunScheduledInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = RunScheduledInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  RunScheduledInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginRunScheduledInstances.</param>
        /// 
        /// <returns>Returns a  RunScheduledInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/RunScheduledInstances">REST API Reference for RunScheduledInstances Operation</seealso>
        public virtual RunScheduledInstancesResponse EndRunScheduledInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<RunScheduledInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  SearchLocalGatewayRoutes

        /// <summary>
        /// Searches for routes in the specified local gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the SearchLocalGatewayRoutes service method.</param>
        /// 
        /// <returns>The response from the SearchLocalGatewayRoutes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchLocalGatewayRoutes">REST API Reference for SearchLocalGatewayRoutes Operation</seealso>
        public virtual SearchLocalGatewayRoutesResponse SearchLocalGatewayRoutes(SearchLocalGatewayRoutesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = SearchLocalGatewayRoutesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = SearchLocalGatewayRoutesResponseUnmarshaller.Instance;

            return Invoke<SearchLocalGatewayRoutesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the SearchLocalGatewayRoutes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the SearchLocalGatewayRoutes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSearchLocalGatewayRoutes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchLocalGatewayRoutes">REST API Reference for SearchLocalGatewayRoutes Operation</seealso>
        public virtual IAsyncResult BeginSearchLocalGatewayRoutes(SearchLocalGatewayRoutesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = SearchLocalGatewayRoutesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = SearchLocalGatewayRoutesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  SearchLocalGatewayRoutes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginSearchLocalGatewayRoutes.</param>
        /// 
        /// <returns>Returns a  SearchLocalGatewayRoutesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchLocalGatewayRoutes">REST API Reference for SearchLocalGatewayRoutes Operation</seealso>
        public virtual SearchLocalGatewayRoutesResponse EndSearchLocalGatewayRoutes(IAsyncResult asyncResult)
        {
            return EndInvoke<SearchLocalGatewayRoutesResponse>(asyncResult);
        }

        #endregion
        
        #region  SearchTransitGatewayMulticastGroups

        /// <summary>
        /// Searches one or more transit gateway multicast groups and returns the group membership
        /// information.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the SearchTransitGatewayMulticastGroups service method.</param>
        /// 
        /// <returns>The response from the SearchTransitGatewayMulticastGroups service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchTransitGatewayMulticastGroups">REST API Reference for SearchTransitGatewayMulticastGroups Operation</seealso>
        public virtual SearchTransitGatewayMulticastGroupsResponse SearchTransitGatewayMulticastGroups(SearchTransitGatewayMulticastGroupsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = SearchTransitGatewayMulticastGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = SearchTransitGatewayMulticastGroupsResponseUnmarshaller.Instance;

            return Invoke<SearchTransitGatewayMulticastGroupsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the SearchTransitGatewayMulticastGroups operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the SearchTransitGatewayMulticastGroups operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSearchTransitGatewayMulticastGroups
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchTransitGatewayMulticastGroups">REST API Reference for SearchTransitGatewayMulticastGroups Operation</seealso>
        public virtual IAsyncResult BeginSearchTransitGatewayMulticastGroups(SearchTransitGatewayMulticastGroupsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = SearchTransitGatewayMulticastGroupsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = SearchTransitGatewayMulticastGroupsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  SearchTransitGatewayMulticastGroups operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginSearchTransitGatewayMulticastGroups.</param>
        /// 
        /// <returns>Returns a  SearchTransitGatewayMulticastGroupsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchTransitGatewayMulticastGroups">REST API Reference for SearchTransitGatewayMulticastGroups Operation</seealso>
        public virtual SearchTransitGatewayMulticastGroupsResponse EndSearchTransitGatewayMulticastGroups(IAsyncResult asyncResult)
        {
            return EndInvoke<SearchTransitGatewayMulticastGroupsResponse>(asyncResult);
        }

        #endregion
        
        #region  SearchTransitGatewayRoutes

        /// <summary>
        /// Searches for routes in the specified transit gateway route table.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the SearchTransitGatewayRoutes service method.</param>
        /// 
        /// <returns>The response from the SearchTransitGatewayRoutes service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchTransitGatewayRoutes">REST API Reference for SearchTransitGatewayRoutes Operation</seealso>
        public virtual SearchTransitGatewayRoutesResponse SearchTransitGatewayRoutes(SearchTransitGatewayRoutesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = SearchTransitGatewayRoutesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = SearchTransitGatewayRoutesResponseUnmarshaller.Instance;

            return Invoke<SearchTransitGatewayRoutesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the SearchTransitGatewayRoutes operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the SearchTransitGatewayRoutes operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSearchTransitGatewayRoutes
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchTransitGatewayRoutes">REST API Reference for SearchTransitGatewayRoutes Operation</seealso>
        public virtual IAsyncResult BeginSearchTransitGatewayRoutes(SearchTransitGatewayRoutesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = SearchTransitGatewayRoutesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = SearchTransitGatewayRoutesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  SearchTransitGatewayRoutes operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginSearchTransitGatewayRoutes.</param>
        /// 
        /// <returns>Returns a  SearchTransitGatewayRoutesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SearchTransitGatewayRoutes">REST API Reference for SearchTransitGatewayRoutes Operation</seealso>
        public virtual SearchTransitGatewayRoutesResponse EndSearchTransitGatewayRoutes(IAsyncResult asyncResult)
        {
            return EndInvoke<SearchTransitGatewayRoutesResponse>(asyncResult);
        }

        #endregion
        
        #region  SendDiagnosticInterrupt

        /// <summary>
        /// Sends a diagnostic interrupt to the specified Amazon EC2 instance to trigger a <i>kernel
        /// panic</i> (on Linux instances), or a <i>blue screen</i>/<i>stop error</i> (on Windows
        /// instances). For instances based on Intel and AMD processors, the interrupt is received
        /// as a <i>non-maskable interrupt</i> (NMI).
        /// 
        ///  
        /// <para>
        /// In general, the operating system crashes and reboots when a kernel panic or stop error
        /// is triggered. The operating system can also be configured to perform diagnostic tasks,
        /// such as generating a memory dump file, loading a secondary kernel, or obtaining a
        /// call trace.
        /// </para>
        ///  
        /// <para>
        /// Before sending a diagnostic interrupt to your instance, ensure that its operating
        /// system is configured to perform the required diagnostic tasks.
        /// </para>
        ///  
        /// <para>
        /// For more information about configuring your operating system to generate a crash dump
        /// when a kernel panic or stop error occurs, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/diagnostic-interrupt.html">Send
        /// a diagnostic interrupt (for advanced users)</a> (Linux instances) or <a href="https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/diagnostic-interrupt.html">Send
        /// a diagnostic interrupt (for advanced users)</a> (Windows instances).
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the SendDiagnosticInterrupt service method.</param>
        /// 
        /// <returns>The response from the SendDiagnosticInterrupt service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SendDiagnosticInterrupt">REST API Reference for SendDiagnosticInterrupt Operation</seealso>
        public virtual SendDiagnosticInterruptResponse SendDiagnosticInterrupt(SendDiagnosticInterruptRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = SendDiagnosticInterruptRequestMarshaller.Instance;
            options.ResponseUnmarshaller = SendDiagnosticInterruptResponseUnmarshaller.Instance;

            return Invoke<SendDiagnosticInterruptResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the SendDiagnosticInterrupt operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the SendDiagnosticInterrupt operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendDiagnosticInterrupt
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SendDiagnosticInterrupt">REST API Reference for SendDiagnosticInterrupt Operation</seealso>
        public virtual IAsyncResult BeginSendDiagnosticInterrupt(SendDiagnosticInterruptRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = SendDiagnosticInterruptRequestMarshaller.Instance;
            options.ResponseUnmarshaller = SendDiagnosticInterruptResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  SendDiagnosticInterrupt operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginSendDiagnosticInterrupt.</param>
        /// 
        /// <returns>Returns a  SendDiagnosticInterruptResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/SendDiagnosticInterrupt">REST API Reference for SendDiagnosticInterrupt Operation</seealso>
        public virtual SendDiagnosticInterruptResponse EndSendDiagnosticInterrupt(IAsyncResult asyncResult)
        {
            return EndInvoke<SendDiagnosticInterruptResponse>(asyncResult);
        }

        #endregion
        
        #region  StartInstances

        /// <summary>
        /// Starts an Amazon EBS-backed instance that you've previously stopped.
        /// 
        ///  
        /// <para>
        /// Instances that use Amazon EBS volumes as their root devices can be quickly stopped
        /// and started. When an instance is stopped, the compute resources are released and you
        /// are not billed for instance usage. However, your root partition Amazon EBS volume
        /// remains and continues to persist your data, and you are charged for Amazon EBS volume
        /// usage. You can restart your instance at any time. Every time you start your instance,
        /// Amazon EC2 charges a one-minute minimum for instance usage, and thereafter charges
        /// per second for instance usage.
        /// </para>
        ///  
        /// <para>
        /// Before stopping an instance, make sure it is in a state from which it can be restarted.
        /// Stopping an instance does not preserve data stored in RAM.
        /// </para>
        ///  
        /// <para>
        /// Performing this operation on an instance that uses an instance store as its root device
        /// returns an error.
        /// </para>
        ///  
        /// <para>
        /// If you attempt to start a T3 instance with <code>host</code> tenancy and the <code>unlimted</code>
        /// CPU credit option, the request fails. The <code>unlimited</code> CPU credit option
        /// is not supported on Dedicated Hosts. Before you start the instance, either change
        /// its CPU credit option to <code>standard</code>, or change its tenancy to <code>default</code>
        /// or <code>dedicated</code>.
        /// </para>
        ///  
        /// <para>
        /// For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html">Stop
        /// and start your instance</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the StartInstances service method.</param>
        /// 
        /// <returns>The response from the StartInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartInstances">REST API Reference for StartInstances Operation</seealso>
        public virtual StartInstancesResponse StartInstances(StartInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartInstancesResponseUnmarshaller.Instance;

            return Invoke<StartInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the StartInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the StartInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartInstances">REST API Reference for StartInstances Operation</seealso>
        public virtual IAsyncResult BeginStartInstances(StartInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  StartInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginStartInstances.</param>
        /// 
        /// <returns>Returns a  StartInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartInstances">REST API Reference for StartInstances Operation</seealso>
        public virtual StartInstancesResponse EndStartInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<StartInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  StartNetworkInsightsAccessScopeAnalysis

        /// <summary>
        /// Starts analyzing the specified Network Access Scope.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the StartNetworkInsightsAccessScopeAnalysis service method.</param>
        /// 
        /// <returns>The response from the StartNetworkInsightsAccessScopeAnalysis service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartNetworkInsightsAccessScopeAnalysis">REST API Reference for StartNetworkInsightsAccessScopeAnalysis Operation</seealso>
        public virtual StartNetworkInsightsAccessScopeAnalysisResponse StartNetworkInsightsAccessScopeAnalysis(StartNetworkInsightsAccessScopeAnalysisRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartNetworkInsightsAccessScopeAnalysisRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartNetworkInsightsAccessScopeAnalysisResponseUnmarshaller.Instance;

            return Invoke<StartNetworkInsightsAccessScopeAnalysisResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the StartNetworkInsightsAccessScopeAnalysis operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the StartNetworkInsightsAccessScopeAnalysis operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartNetworkInsightsAccessScopeAnalysis
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartNetworkInsightsAccessScopeAnalysis">REST API Reference for StartNetworkInsightsAccessScopeAnalysis Operation</seealso>
        public virtual IAsyncResult BeginStartNetworkInsightsAccessScopeAnalysis(StartNetworkInsightsAccessScopeAnalysisRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartNetworkInsightsAccessScopeAnalysisRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartNetworkInsightsAccessScopeAnalysisResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  StartNetworkInsightsAccessScopeAnalysis operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginStartNetworkInsightsAccessScopeAnalysis.</param>
        /// 
        /// <returns>Returns a  StartNetworkInsightsAccessScopeAnalysisResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartNetworkInsightsAccessScopeAnalysis">REST API Reference for StartNetworkInsightsAccessScopeAnalysis Operation</seealso>
        public virtual StartNetworkInsightsAccessScopeAnalysisResponse EndStartNetworkInsightsAccessScopeAnalysis(IAsyncResult asyncResult)
        {
            return EndInvoke<StartNetworkInsightsAccessScopeAnalysisResponse>(asyncResult);
        }

        #endregion
        
        #region  StartNetworkInsightsAnalysis

        /// <summary>
        /// Starts analyzing the specified path. If the path is reachable, the operation returns
        /// the shortest feasible path.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the StartNetworkInsightsAnalysis service method.</param>
        /// 
        /// <returns>The response from the StartNetworkInsightsAnalysis service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartNetworkInsightsAnalysis">REST API Reference for StartNetworkInsightsAnalysis Operation</seealso>
        public virtual StartNetworkInsightsAnalysisResponse StartNetworkInsightsAnalysis(StartNetworkInsightsAnalysisRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartNetworkInsightsAnalysisRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartNetworkInsightsAnalysisResponseUnmarshaller.Instance;

            return Invoke<StartNetworkInsightsAnalysisResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the StartNetworkInsightsAnalysis operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the StartNetworkInsightsAnalysis operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartNetworkInsightsAnalysis
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartNetworkInsightsAnalysis">REST API Reference for StartNetworkInsightsAnalysis Operation</seealso>
        public virtual IAsyncResult BeginStartNetworkInsightsAnalysis(StartNetworkInsightsAnalysisRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartNetworkInsightsAnalysisRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartNetworkInsightsAnalysisResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  StartNetworkInsightsAnalysis operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginStartNetworkInsightsAnalysis.</param>
        /// 
        /// <returns>Returns a  StartNetworkInsightsAnalysisResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartNetworkInsightsAnalysis">REST API Reference for StartNetworkInsightsAnalysis Operation</seealso>
        public virtual StartNetworkInsightsAnalysisResponse EndStartNetworkInsightsAnalysis(IAsyncResult asyncResult)
        {
            return EndInvoke<StartNetworkInsightsAnalysisResponse>(asyncResult);
        }

        #endregion
        
        #region  StartVpcEndpointServicePrivateDnsVerification

        /// <summary>
        /// Initiates the verification process to prove that the service provider owns the private
        /// DNS name domain for the endpoint service.
        /// 
        ///  
        /// <para>
        /// The service provider must successfully perform the verification before the consumer
        /// can use the name to access the service.
        /// </para>
        ///  
        /// <para>
        /// Before the service provider runs this command, they must add a record to the DNS server.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the StartVpcEndpointServicePrivateDnsVerification service method.</param>
        /// 
        /// <returns>The response from the StartVpcEndpointServicePrivateDnsVerification service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartVpcEndpointServicePrivateDnsVerification">REST API Reference for StartVpcEndpointServicePrivateDnsVerification Operation</seealso>
        public virtual StartVpcEndpointServicePrivateDnsVerificationResponse StartVpcEndpointServicePrivateDnsVerification(StartVpcEndpointServicePrivateDnsVerificationRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartVpcEndpointServicePrivateDnsVerificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartVpcEndpointServicePrivateDnsVerificationResponseUnmarshaller.Instance;

            return Invoke<StartVpcEndpointServicePrivateDnsVerificationResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the StartVpcEndpointServicePrivateDnsVerification operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the StartVpcEndpointServicePrivateDnsVerification operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartVpcEndpointServicePrivateDnsVerification
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartVpcEndpointServicePrivateDnsVerification">REST API Reference for StartVpcEndpointServicePrivateDnsVerification Operation</seealso>
        public virtual IAsyncResult BeginStartVpcEndpointServicePrivateDnsVerification(StartVpcEndpointServicePrivateDnsVerificationRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StartVpcEndpointServicePrivateDnsVerificationRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StartVpcEndpointServicePrivateDnsVerificationResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  StartVpcEndpointServicePrivateDnsVerification operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginStartVpcEndpointServicePrivateDnsVerification.</param>
        /// 
        /// <returns>Returns a  StartVpcEndpointServicePrivateDnsVerificationResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StartVpcEndpointServicePrivateDnsVerification">REST API Reference for StartVpcEndpointServicePrivateDnsVerification Operation</seealso>
        public virtual StartVpcEndpointServicePrivateDnsVerificationResponse EndStartVpcEndpointServicePrivateDnsVerification(IAsyncResult asyncResult)
        {
            return EndInvoke<StartVpcEndpointServicePrivateDnsVerificationResponse>(asyncResult);
        }

        #endregion
        
        #region  StopInstances

        /// <summary>
        /// Stops an Amazon EBS-backed instance. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Stop_Start.html">Stop
        /// and start your instance</a> in the <i>Amazon EC2 User Guide</i>.
        /// 
        ///  
        /// <para>
        /// You can use the Stop action to hibernate an instance if the instance is <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/enabling-hibernation.html">enabled
        /// for hibernation</a> and it meets the <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/hibernating-prerequisites.html">hibernation
        /// prerequisites</a>. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Hibernate.html">Hibernate
        /// your instance</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// We don't charge usage for a stopped instance, or data transfer fees; however, your
        /// root partition Amazon EBS volume remains and continues to persist your data, and you
        /// are charged for Amazon EBS volume usage. Every time you start your instance, Amazon
        /// EC2 charges a one-minute minimum for instance usage, and thereafter charges per second
        /// for instance usage.
        /// </para>
        ///  
        /// <para>
        /// You can't stop or hibernate instance store-backed instances. You can't use the Stop
        /// action to hibernate Spot Instances, but you can specify that Amazon EC2 should hibernate
        /// Spot Instances when they are interrupted. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-interruptions.html#hibernate-spot-instances">Hibernating
        /// interrupted Spot Instances</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// When you stop or hibernate an instance, we shut it down. You can restart your instance
        /// at any time. Before stopping or hibernating an instance, make sure it is in a state
        /// from which it can be restarted. Stopping an instance does not preserve data stored
        /// in RAM, but hibernating an instance does preserve data stored in RAM. If an instance
        /// cannot hibernate successfully, a normal shutdown occurs.
        /// </para>
        ///  
        /// <para>
        /// Stopping and hibernating an instance is different to rebooting or terminating it.
        /// For example, when you stop or hibernate an instance, the root device and any other
        /// devices attached to the instance persist. When you terminate an instance, the root
        /// device and any other devices attached during the instance launch are automatically
        /// deleted. For more information about the differences between rebooting, stopping, hibernating,
        /// and terminating instances, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Instance
        /// lifecycle</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// When you stop an instance, we attempt to shut it down forcibly after a short while.
        /// If your instance appears stuck in the stopping state after a period of time, there
        /// may be an issue with the underlying host computer. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesStopping.html">Troubleshoot
        /// stopping your instance</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the StopInstances service method.</param>
        /// 
        /// <returns>The response from the StopInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StopInstances">REST API Reference for StopInstances Operation</seealso>
        public virtual StopInstancesResponse StopInstances(StopInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StopInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StopInstancesResponseUnmarshaller.Instance;

            return Invoke<StopInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the StopInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the StopInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStopInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StopInstances">REST API Reference for StopInstances Operation</seealso>
        public virtual IAsyncResult BeginStopInstances(StopInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = StopInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = StopInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  StopInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginStopInstances.</param>
        /// 
        /// <returns>Returns a  StopInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/StopInstances">REST API Reference for StopInstances Operation</seealso>
        public virtual StopInstancesResponse EndStopInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<StopInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  TerminateClientVpnConnections

        /// <summary>
        /// Terminates active Client VPN endpoint connections. This action can be used to terminate
        /// a specific client connection, or up to five connections established by a specific
        /// user.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the TerminateClientVpnConnections service method.</param>
        /// 
        /// <returns>The response from the TerminateClientVpnConnections service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/TerminateClientVpnConnections">REST API Reference for TerminateClientVpnConnections Operation</seealso>
        public virtual TerminateClientVpnConnectionsResponse TerminateClientVpnConnections(TerminateClientVpnConnectionsRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = TerminateClientVpnConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = TerminateClientVpnConnectionsResponseUnmarshaller.Instance;

            return Invoke<TerminateClientVpnConnectionsResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the TerminateClientVpnConnections operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the TerminateClientVpnConnections operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTerminateClientVpnConnections
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/TerminateClientVpnConnections">REST API Reference for TerminateClientVpnConnections Operation</seealso>
        public virtual IAsyncResult BeginTerminateClientVpnConnections(TerminateClientVpnConnectionsRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = TerminateClientVpnConnectionsRequestMarshaller.Instance;
            options.ResponseUnmarshaller = TerminateClientVpnConnectionsResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  TerminateClientVpnConnections operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginTerminateClientVpnConnections.</param>
        /// 
        /// <returns>Returns a  TerminateClientVpnConnectionsResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/TerminateClientVpnConnections">REST API Reference for TerminateClientVpnConnections Operation</seealso>
        public virtual TerminateClientVpnConnectionsResponse EndTerminateClientVpnConnections(IAsyncResult asyncResult)
        {
            return EndInvoke<TerminateClientVpnConnectionsResponse>(asyncResult);
        }

        #endregion
        
        #region  TerminateInstances

        /// <summary>
        /// Shuts down the specified instances. This operation is idempotent; if you terminate
        /// an instance more than once, each call succeeds. 
        /// 
        ///  
        /// <para>
        /// If you specify multiple instances and the request fails (for example, because of a
        /// single incorrect instance ID), none of the instances are terminated.
        /// </para>
        ///  
        /// <para>
        /// If you terminate multiple instances across multiple Availability Zones, and one or
        /// more of the specified instances are enabled for termination protection, the request
        /// fails with the following results:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        /// The specified instances that are in the same Availability Zone as the protected instance
        /// are not terminated.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// The specified instances that are in different Availability Zones, where no other specified
        /// instances are protected, are successfully terminated.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// For example, say you have the following instances:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        /// Instance A: <code>us-east-1a</code>; Not protected
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Instance B: <code>us-east-1a</code>; Not protected
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Instance C: <code>us-east-1b</code>; Protected
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Instance D: <code>us-east-1b</code>; not protected
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// If you attempt to terminate all of these instances in the same request, the request
        /// reports failure with the following results:
        /// </para>
        ///  <ul> <li> 
        /// <para>
        /// Instance A and Instance B are successfully terminated because none of the specified
        /// instances in <code>us-east-1a</code> are enabled for termination protection.
        /// </para>
        ///  </li> <li> 
        /// <para>
        /// Instance C and Instance D fail to terminate because at least one of the specified
        /// instances in <code>us-east-1b</code> (Instance C) is enabled for termination protection.
        /// </para>
        ///  </li> </ul> 
        /// <para>
        /// Terminated instances remain visible after termination (for approximately one hour).
        /// </para>
        ///  
        /// <para>
        /// By default, Amazon EC2 deletes all EBS volumes that were attached when the instance
        /// launched. Volumes attached after instance launch continue running.
        /// </para>
        ///  
        /// <para>
        /// You can stop, start, and terminate EBS-backed instances. You can only terminate instance
        /// store-backed instances. What happens to an instance differs if you stop it or terminate
        /// it. For example, when you stop an instance, the root device and any other devices
        /// attached to the instance persist. When you terminate an instance, any attached EBS
        /// volumes with the <code>DeleteOnTermination</code> block device mapping parameter set
        /// to <code>true</code> are automatically deleted. For more information about the differences
        /// between stopping and terminating instances, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html">Instance
        /// lifecycle</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        ///  
        /// <para>
        /// For more information about troubleshooting, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesShuttingDown.html">Troubleshooting
        /// terminating your instance</a> in the <i>Amazon EC2 User Guide</i>.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the TerminateInstances service method.</param>
        /// 
        /// <returns>The response from the TerminateInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/TerminateInstances">REST API Reference for TerminateInstances Operation</seealso>
        public virtual TerminateInstancesResponse TerminateInstances(TerminateInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = TerminateInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = TerminateInstancesResponseUnmarshaller.Instance;

            return Invoke<TerminateInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the TerminateInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the TerminateInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndTerminateInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/TerminateInstances">REST API Reference for TerminateInstances Operation</seealso>
        public virtual IAsyncResult BeginTerminateInstances(TerminateInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = TerminateInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = TerminateInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  TerminateInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginTerminateInstances.</param>
        /// 
        /// <returns>Returns a  TerminateInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/TerminateInstances">REST API Reference for TerminateInstances Operation</seealso>
        public virtual TerminateInstancesResponse EndTerminateInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<TerminateInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  UnassignIpv6Addresses

        /// <summary>
        /// Unassigns one or more IPv6 addresses IPv4 Prefix Delegation prefixes from a network
        /// interface.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the UnassignIpv6Addresses service method.</param>
        /// 
        /// <returns>The response from the UnassignIpv6Addresses service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignIpv6Addresses">REST API Reference for UnassignIpv6Addresses Operation</seealso>
        public virtual UnassignIpv6AddressesResponse UnassignIpv6Addresses(UnassignIpv6AddressesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UnassignIpv6AddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UnassignIpv6AddressesResponseUnmarshaller.Instance;

            return Invoke<UnassignIpv6AddressesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the UnassignIpv6Addresses operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the UnassignIpv6Addresses operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUnassignIpv6Addresses
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignIpv6Addresses">REST API Reference for UnassignIpv6Addresses Operation</seealso>
        public virtual IAsyncResult BeginUnassignIpv6Addresses(UnassignIpv6AddressesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UnassignIpv6AddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UnassignIpv6AddressesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  UnassignIpv6Addresses operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginUnassignIpv6Addresses.</param>
        /// 
        /// <returns>Returns a  UnassignIpv6AddressesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignIpv6Addresses">REST API Reference for UnassignIpv6Addresses Operation</seealso>
        public virtual UnassignIpv6AddressesResponse EndUnassignIpv6Addresses(IAsyncResult asyncResult)
        {
            return EndInvoke<UnassignIpv6AddressesResponse>(asyncResult);
        }

        #endregion
        
        #region  UnassignPrivateIpAddresses

        /// <summary>
        /// Unassigns one or more secondary private IP addresses, or IPv4 Prefix Delegation prefixes
        /// from a network interface.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the UnassignPrivateIpAddresses service method.</param>
        /// 
        /// <returns>The response from the UnassignPrivateIpAddresses service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignPrivateIpAddresses">REST API Reference for UnassignPrivateIpAddresses Operation</seealso>
        public virtual UnassignPrivateIpAddressesResponse UnassignPrivateIpAddresses(UnassignPrivateIpAddressesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UnassignPrivateIpAddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UnassignPrivateIpAddressesResponseUnmarshaller.Instance;

            return Invoke<UnassignPrivateIpAddressesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the UnassignPrivateIpAddresses operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the UnassignPrivateIpAddresses operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUnassignPrivateIpAddresses
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignPrivateIpAddresses">REST API Reference for UnassignPrivateIpAddresses Operation</seealso>
        public virtual IAsyncResult BeginUnassignPrivateIpAddresses(UnassignPrivateIpAddressesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UnassignPrivateIpAddressesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UnassignPrivateIpAddressesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  UnassignPrivateIpAddresses operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginUnassignPrivateIpAddresses.</param>
        /// 
        /// <returns>Returns a  UnassignPrivateIpAddressesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignPrivateIpAddresses">REST API Reference for UnassignPrivateIpAddresses Operation</seealso>
        public virtual UnassignPrivateIpAddressesResponse EndUnassignPrivateIpAddresses(IAsyncResult asyncResult)
        {
            return EndInvoke<UnassignPrivateIpAddressesResponse>(asyncResult);
        }

        #endregion
        
        #region  UnassignPrivateNatGatewayAddress

        /// <summary>
        /// Unassigns secondary private IPv4 addresses from a private NAT gateway. You cannot
        /// unassign your primary private IP. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-edit-secondary">Edit
        /// secondary IP address associations</a> in the <i>Amazon VPC User Guide</i>.
        /// 
        ///  
        /// <para>
        /// While unassigning is in progress, you cannot assign/unassign additional IP addresses
        /// while the connections are being drained. You are, however, allowed to delete the NAT
        /// gateway.
        /// </para>
        ///  
        /// <para>
        /// A private IP address will only be released at the end of MaxDrainDurationSeconds.
        /// The private IP addresses stay associated and support the existing connections, but
        /// do not support any new connections (new connections are distributed across the remaining
        /// assigned private IP address). After the existing connections drain out, the private
        /// IP addresses are released.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the UnassignPrivateNatGatewayAddress service method.</param>
        /// 
        /// <returns>The response from the UnassignPrivateNatGatewayAddress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignPrivateNatGatewayAddress">REST API Reference for UnassignPrivateNatGatewayAddress Operation</seealso>
        public virtual UnassignPrivateNatGatewayAddressResponse UnassignPrivateNatGatewayAddress(UnassignPrivateNatGatewayAddressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UnassignPrivateNatGatewayAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UnassignPrivateNatGatewayAddressResponseUnmarshaller.Instance;

            return Invoke<UnassignPrivateNatGatewayAddressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the UnassignPrivateNatGatewayAddress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the UnassignPrivateNatGatewayAddress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUnassignPrivateNatGatewayAddress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignPrivateNatGatewayAddress">REST API Reference for UnassignPrivateNatGatewayAddress Operation</seealso>
        public virtual IAsyncResult BeginUnassignPrivateNatGatewayAddress(UnassignPrivateNatGatewayAddressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UnassignPrivateNatGatewayAddressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UnassignPrivateNatGatewayAddressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  UnassignPrivateNatGatewayAddress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginUnassignPrivateNatGatewayAddress.</param>
        /// 
        /// <returns>Returns a  UnassignPrivateNatGatewayAddressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnassignPrivateNatGatewayAddress">REST API Reference for UnassignPrivateNatGatewayAddress Operation</seealso>
        public virtual UnassignPrivateNatGatewayAddressResponse EndUnassignPrivateNatGatewayAddress(IAsyncResult asyncResult)
        {
            return EndInvoke<UnassignPrivateNatGatewayAddressResponse>(asyncResult);
        }

        #endregion
        
        #region  UnmonitorInstances

        /// <summary>
        /// Disables detailed monitoring for a running instance. For more information, see <a
        /// href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-cloudwatch.html">Monitoring
        /// your instances and volumes</a> in the <i>Amazon EC2 User Guide</i>.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the UnmonitorInstances service method.</param>
        /// 
        /// <returns>The response from the UnmonitorInstances service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnmonitorInstances">REST API Reference for UnmonitorInstances Operation</seealso>
        public virtual UnmonitorInstancesResponse UnmonitorInstances(UnmonitorInstancesRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UnmonitorInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UnmonitorInstancesResponseUnmarshaller.Instance;

            return Invoke<UnmonitorInstancesResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the UnmonitorInstances operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the UnmonitorInstances operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUnmonitorInstances
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnmonitorInstances">REST API Reference for UnmonitorInstances Operation</seealso>
        public virtual IAsyncResult BeginUnmonitorInstances(UnmonitorInstancesRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UnmonitorInstancesRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UnmonitorInstancesResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  UnmonitorInstances operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginUnmonitorInstances.</param>
        /// 
        /// <returns>Returns a  UnmonitorInstancesResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UnmonitorInstances">REST API Reference for UnmonitorInstances Operation</seealso>
        public virtual UnmonitorInstancesResponse EndUnmonitorInstances(IAsyncResult asyncResult)
        {
            return EndInvoke<UnmonitorInstancesResponse>(asyncResult);
        }

        #endregion
        
        #region  UpdateSecurityGroupRuleDescriptionsEgress

        /// <summary>
        /// Updates the description of an egress (outbound) security group rule. You can replace
        /// an existing description, or add a description to a rule that did not have one previously.
        /// You can remove a description for a security group rule by omitting the description
        /// parameter in the request.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the UpdateSecurityGroupRuleDescriptionsEgress service method.</param>
        /// 
        /// <returns>The response from the UpdateSecurityGroupRuleDescriptionsEgress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateSecurityGroupRuleDescriptionsEgress">REST API Reference for UpdateSecurityGroupRuleDescriptionsEgress Operation</seealso>
        public virtual UpdateSecurityGroupRuleDescriptionsEgressResponse UpdateSecurityGroupRuleDescriptionsEgress(UpdateSecurityGroupRuleDescriptionsEgressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateSecurityGroupRuleDescriptionsEgressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateSecurityGroupRuleDescriptionsEgressResponseUnmarshaller.Instance;

            return Invoke<UpdateSecurityGroupRuleDescriptionsEgressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the UpdateSecurityGroupRuleDescriptionsEgress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the UpdateSecurityGroupRuleDescriptionsEgress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateSecurityGroupRuleDescriptionsEgress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateSecurityGroupRuleDescriptionsEgress">REST API Reference for UpdateSecurityGroupRuleDescriptionsEgress Operation</seealso>
        public virtual IAsyncResult BeginUpdateSecurityGroupRuleDescriptionsEgress(UpdateSecurityGroupRuleDescriptionsEgressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateSecurityGroupRuleDescriptionsEgressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateSecurityGroupRuleDescriptionsEgressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  UpdateSecurityGroupRuleDescriptionsEgress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateSecurityGroupRuleDescriptionsEgress.</param>
        /// 
        /// <returns>Returns a  UpdateSecurityGroupRuleDescriptionsEgressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateSecurityGroupRuleDescriptionsEgress">REST API Reference for UpdateSecurityGroupRuleDescriptionsEgress Operation</seealso>
        public virtual UpdateSecurityGroupRuleDescriptionsEgressResponse EndUpdateSecurityGroupRuleDescriptionsEgress(IAsyncResult asyncResult)
        {
            return EndInvoke<UpdateSecurityGroupRuleDescriptionsEgressResponse>(asyncResult);
        }

        #endregion
        
        #region  UpdateSecurityGroupRuleDescriptionsIngress

        /// <summary>
        /// Updates the description of an ingress (inbound) security group rule. You can replace
        /// an existing description, or add a description to a rule that did not have one previously.
        /// You can remove a description for a security group rule by omitting the description
        /// parameter in the request.
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the UpdateSecurityGroupRuleDescriptionsIngress service method.</param>
        /// 
        /// <returns>The response from the UpdateSecurityGroupRuleDescriptionsIngress service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateSecurityGroupRuleDescriptionsIngress">REST API Reference for UpdateSecurityGroupRuleDescriptionsIngress Operation</seealso>
        public virtual UpdateSecurityGroupRuleDescriptionsIngressResponse UpdateSecurityGroupRuleDescriptionsIngress(UpdateSecurityGroupRuleDescriptionsIngressRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateSecurityGroupRuleDescriptionsIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateSecurityGroupRuleDescriptionsIngressResponseUnmarshaller.Instance;

            return Invoke<UpdateSecurityGroupRuleDescriptionsIngressResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the UpdateSecurityGroupRuleDescriptionsIngress operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the UpdateSecurityGroupRuleDescriptionsIngress operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateSecurityGroupRuleDescriptionsIngress
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateSecurityGroupRuleDescriptionsIngress">REST API Reference for UpdateSecurityGroupRuleDescriptionsIngress Operation</seealso>
        public virtual IAsyncResult BeginUpdateSecurityGroupRuleDescriptionsIngress(UpdateSecurityGroupRuleDescriptionsIngressRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = UpdateSecurityGroupRuleDescriptionsIngressRequestMarshaller.Instance;
            options.ResponseUnmarshaller = UpdateSecurityGroupRuleDescriptionsIngressResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  UpdateSecurityGroupRuleDescriptionsIngress operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginUpdateSecurityGroupRuleDescriptionsIngress.</param>
        /// 
        /// <returns>Returns a  UpdateSecurityGroupRuleDescriptionsIngressResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/UpdateSecurityGroupRuleDescriptionsIngress">REST API Reference for UpdateSecurityGroupRuleDescriptionsIngress Operation</seealso>
        public virtual UpdateSecurityGroupRuleDescriptionsIngressResponse EndUpdateSecurityGroupRuleDescriptionsIngress(IAsyncResult asyncResult)
        {
            return EndInvoke<UpdateSecurityGroupRuleDescriptionsIngressResponse>(asyncResult);
        }

        #endregion
        
        #region  WithdrawByoipCidr

        /// <summary>
        /// Stops advertising an address range that is provisioned as an address pool.
        /// 
        ///  
        /// <para>
        /// You can perform this operation at most once every 10 seconds, even if you specify
        /// different address ranges each time.
        /// </para>
        ///  
        /// <para>
        /// It can take a few minutes before traffic to the specified addresses stops routing
        /// to Amazon Web Services because of BGP propagation delays.
        /// </para>
        /// </summary>
        /// <param name="request">Container for the necessary parameters to execute the WithdrawByoipCidr service method.</param>
        /// 
        /// <returns>The response from the WithdrawByoipCidr service method, as returned by EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/WithdrawByoipCidr">REST API Reference for WithdrawByoipCidr Operation</seealso>
        public virtual WithdrawByoipCidrResponse WithdrawByoipCidr(WithdrawByoipCidrRequest request)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = WithdrawByoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = WithdrawByoipCidrResponseUnmarshaller.Instance;

            return Invoke<WithdrawByoipCidrResponse>(request, options);
        }

        /// <summary>
        /// Initiates the asynchronous execution of the WithdrawByoipCidr operation.
        /// </summary>
        /// 
        /// <param name="request">Container for the necessary parameters to execute the WithdrawByoipCidr operation on AmazonEC2Client.</param>
        /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
        /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
        ///          procedure using the AsyncState property.</param>
        /// 
        /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndWithdrawByoipCidr
        ///         operation.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/WithdrawByoipCidr">REST API Reference for WithdrawByoipCidr Operation</seealso>
        public virtual IAsyncResult BeginWithdrawByoipCidr(WithdrawByoipCidrRequest request, AsyncCallback callback, object state)
        {
            var options = new InvokeOptions();
            options.RequestMarshaller = WithdrawByoipCidrRequestMarshaller.Instance;
            options.ResponseUnmarshaller = WithdrawByoipCidrResponseUnmarshaller.Instance;

            return BeginInvoke(request, options, callback, state);
        }

        /// <summary>
        /// Finishes the asynchronous execution of the  WithdrawByoipCidr operation.
        /// </summary>
        /// 
        /// <param name="asyncResult">The IAsyncResult returned by the call to BeginWithdrawByoipCidr.</param>
        /// 
        /// <returns>Returns a  WithdrawByoipCidrResult from EC2.</returns>
        /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/ec2-2016-11-15/WithdrawByoipCidr">REST API Reference for WithdrawByoipCidr Operation</seealso>
        public virtual WithdrawByoipCidrResponse EndWithdrawByoipCidr(IAsyncResult asyncResult)
        {
            return EndInvoke<WithdrawByoipCidrResponse>(asyncResult);
        }

        #endregion
        
    }
}