All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.amazonaws.services.ec2.AmazonEC2AsyncClient Maven / Gradle / Ivy

Go to download 

/*
 * Copyright 2017-2022 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.
 */
package com.amazonaws.services.ec2;

import static java.util.concurrent.Executors.newFixedThreadPool;

import javax.annotation.Generated;

import com.amazonaws.services.ec2.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import java.util.concurrent.ExecutorService;
import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;

/**
 * Client for accessing Amazon EC2 asynchronously. Each asynchronous method will return a Java Future object
 * representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
 * notification when an asynchronous operation completes.
 * 

 * Amazon Elastic Compute Cloud
 * 

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

 * 

 * To learn more, see the following resources:
 * 

 * 
 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonEC2AsyncClient extends AmazonEC2Client implements AmazonEC2Async {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2. A credentials provider chain will
     * be used that searches for credentials in this order:
     * 
    
     * 
  • Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
    • 
     * 
  • Java System Properties - aws.accessKeyId and aws.secretKey
    • 
     * 
  • Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
    • 
     * 
  • Instance profile credentials delivered through the Amazon EC2 metadata service
    • 
     * 

     * 

     * Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
     * maximum number of concurrent connections to the service).
     *
     * @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
     * @see java.util.concurrent.Executors#newFixedThreadPool(int)
     * @deprecated use {@link AmazonEC2AsyncClientBuilder#defaultClient()}
     */
    @Deprecated
    public AmazonEC2AsyncClient() {
        this(DefaultAWSCredentialsProviderChain.getInstance());
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2. A credentials provider chain will
     * be used that searches for credentials in this order:
     * 
    
     * 
  • Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
    • 
     * 
  • Java System Properties - aws.accessKeyId and aws.secretKey
    • 
     * 
  • Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI
    • 
     * 
  • Instance profile credentials delivered through the Amazon EC2 metadata service
    • 
     * 

     * 

     * Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
     * maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
     *
     * @param clientConfiguration
     *        The client configuration options controlling how this client connects to Amazon EC2 (ex: proxy settings,
     *        retry counts, etc).
     *
     * @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
     * @see java.util.concurrent.Executors#newFixedThreadPool(int)
     * @deprecated use {@link AmazonEC2AsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
     */
    @Deprecated
    public AmazonEC2AsyncClient(ClientConfiguration clientConfiguration) {
        this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2 using the specified AWS account
     * credentials.
     * 

     * Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
     * maximum number of concurrent connections to the service).
     *
     * @param awsCredentials
     *        The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
     * @see java.util.concurrent.Executors#newFixedThreadPool(int)
     * @deprecated use {@link AmazonEC2AsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
     */
    @Deprecated
    public AmazonEC2AsyncClient(AWSCredentials awsCredentials) {
        this(awsCredentials, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2 using the specified AWS account
     * credentials and executor service. Default client settings will be used.
     *
     * @param awsCredentials
     *        The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
     * @param executorService
     *        The executor service by which all asynchronous requests will be executed.
     * @deprecated use {@link AmazonEC2AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
     *             {@link AmazonEC2AsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
     */
    @Deprecated
    public AmazonEC2AsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) {

        this(awsCredentials, configFactory.getConfig(), executorService);
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2 using the specified AWS account
     * credentials, executor service, and client configuration options.
     *
     * @param awsCredentials
     *        The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
     * @param clientConfiguration
     *        Client configuration options (ex: max retry limit, proxy settings, etc).
     * @param executorService
     *        The executor service by which all asynchronous requests will be executed.
     * @deprecated use {@link AmazonEC2AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
     *             {@link AmazonEC2AsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
     *             {@link AmazonEC2AsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
     */
    @Deprecated
    public AmazonEC2AsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, ExecutorService executorService) {
        super(awsCredentials, clientConfiguration);
        this.executorService = executorService;
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2 using the specified AWS account
     * credentials provider. Default client settings will be used.
     * 

     * Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
     * maximum number of concurrent connections to the service).
     *
     * @param awsCredentialsProvider
     *        The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
     * @see java.util.concurrent.Executors#newFixedThreadPool(int)
     * @deprecated use {@link AmazonEC2AsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
     */
    @Deprecated
    public AmazonEC2AsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
        this(awsCredentialsProvider, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2 using the provided AWS account
     * credentials provider and client configuration options.
     * 

     * Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
     * maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
     *
     * @param awsCredentialsProvider
     *        The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
     * @param clientConfiguration
     *        Client configuration options (ex: max retry limit, proxy settings, etc).
     *
     * @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
     * @see java.util.concurrent.Executors#newFixedThreadPool(int)
     * @deprecated use {@link AmazonEC2AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
     *             {@link AmazonEC2AsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
     */
    @Deprecated
    public AmazonEC2AsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
        this(awsCredentialsProvider, clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2 using the specified AWS account
     * credentials provider and executor service. Default client settings will be used.
     *
     * @param awsCredentialsProvider
     *        The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
     * @param executorService
     *        The executor service by which all asynchronous requests will be executed.
     * @deprecated use {@link AmazonEC2AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
     *             {@link AmazonEC2AsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
     */
    @Deprecated
    public AmazonEC2AsyncClient(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
        this(awsCredentialsProvider, configFactory.getConfig(), executorService);
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2 using the specified AWS account
     * credentials provider, executor service, and client configuration options.
     *
     * @param awsCredentialsProvider
     *        The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
     * @param clientConfiguration
     *        Client configuration options (ex: max retry limit, proxy settings, etc).
     * @param executorService
     *        The executor service by which all asynchronous requests will be executed.
     * @deprecated use {@link AmazonEC2AsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
     *             {@link AmazonEC2AsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
     *             {@link AmazonEC2AsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
     */
    @Deprecated
    public AmazonEC2AsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, ExecutorService executorService) {
        super(awsCredentialsProvider, clientConfiguration);
        this.executorService = executorService;
    }

    public static AmazonEC2AsyncClientBuilder asyncBuilder() {
        return AmazonEC2AsyncClientBuilder.standard();
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2 using the specified parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     */
    AmazonEC2AsyncClient(AwsAsyncClientParams asyncClientParams) {
        this(asyncClientParams, false);
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon EC2 using the specified parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     * @param endpointDiscoveryEnabled
     *        true will enable endpoint discovery if the service supports it.
     */
    AmazonEC2AsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
        super(asyncClientParams, endpointDiscoveryEnabled);
        this.executorService = asyncClientParams.getExecutor();
    }

    /**
     * Returns the executor service used by this client to execute async requests.
     *
     * @return The executor service used by this client to execute async requests.
     */
    public ExecutorService getExecutorService() {
        return executorService;
    }

    @Override
    public java.util.concurrent.Future acceptReservedInstancesExchangeQuoteAsync(
            AcceptReservedInstancesExchangeQuoteRequest request) {

        return acceptReservedInstancesExchangeQuoteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future acceptReservedInstancesExchangeQuoteAsync(
            final AcceptReservedInstancesExchangeQuoteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AcceptReservedInstancesExchangeQuoteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AcceptReservedInstancesExchangeQuoteResult call() throws Exception {
                AcceptReservedInstancesExchangeQuoteResult result = null;

                try {
                    result = executeAcceptReservedInstancesExchangeQuote(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future acceptTransitGatewayMulticastDomainAssociationsAsync(
            AcceptTransitGatewayMulticastDomainAssociationsRequest request) {

        return acceptTransitGatewayMulticastDomainAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future acceptTransitGatewayMulticastDomainAssociationsAsync(
            final AcceptTransitGatewayMulticastDomainAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AcceptTransitGatewayMulticastDomainAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AcceptTransitGatewayMulticastDomainAssociationsResult call() throws Exception {
                AcceptTransitGatewayMulticastDomainAssociationsResult result = null;

                try {
                    result = executeAcceptTransitGatewayMulticastDomainAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future acceptTransitGatewayPeeringAttachmentAsync(
            AcceptTransitGatewayPeeringAttachmentRequest request) {

        return acceptTransitGatewayPeeringAttachmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future acceptTransitGatewayPeeringAttachmentAsync(
            final AcceptTransitGatewayPeeringAttachmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AcceptTransitGatewayPeeringAttachmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AcceptTransitGatewayPeeringAttachmentResult call() throws Exception {
                AcceptTransitGatewayPeeringAttachmentResult result = null;

                try {
                    result = executeAcceptTransitGatewayPeeringAttachment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future acceptTransitGatewayVpcAttachmentAsync(
            AcceptTransitGatewayVpcAttachmentRequest request) {

        return acceptTransitGatewayVpcAttachmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future acceptTransitGatewayVpcAttachmentAsync(
            final AcceptTransitGatewayVpcAttachmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AcceptTransitGatewayVpcAttachmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AcceptTransitGatewayVpcAttachmentResult call() throws Exception {
                AcceptTransitGatewayVpcAttachmentResult result = null;

                try {
                    result = executeAcceptTransitGatewayVpcAttachment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future acceptVpcEndpointConnectionsAsync(AcceptVpcEndpointConnectionsRequest request) {

        return acceptVpcEndpointConnectionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future acceptVpcEndpointConnectionsAsync(final AcceptVpcEndpointConnectionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AcceptVpcEndpointConnectionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AcceptVpcEndpointConnectionsResult call() throws Exception {
                AcceptVpcEndpointConnectionsResult result = null;

                try {
                    result = executeAcceptVpcEndpointConnections(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future acceptVpcPeeringConnectionAsync(AcceptVpcPeeringConnectionRequest request) {

        return acceptVpcPeeringConnectionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future acceptVpcPeeringConnectionAsync(final AcceptVpcPeeringConnectionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AcceptVpcPeeringConnectionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AcceptVpcPeeringConnectionResult call() throws Exception {
                AcceptVpcPeeringConnectionResult result = null;

                try {
                    result = executeAcceptVpcPeeringConnection(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the AcceptVpcPeeringConnection operation.
     *
     * @see #acceptVpcPeeringConnectionAsync(AcceptVpcPeeringConnectionRequest)
     */
    @Override
    public java.util.concurrent.Future acceptVpcPeeringConnectionAsync() {

        return acceptVpcPeeringConnectionAsync(new AcceptVpcPeeringConnectionRequest());
    }

    /**
     * Simplified method form for invoking the AcceptVpcPeeringConnection operation with an AsyncHandler.
     *
     * @see #acceptVpcPeeringConnectionAsync(AcceptVpcPeeringConnectionRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future acceptVpcPeeringConnectionAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return acceptVpcPeeringConnectionAsync(new AcceptVpcPeeringConnectionRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future advertiseByoipCidrAsync(AdvertiseByoipCidrRequest request) {

        return advertiseByoipCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future advertiseByoipCidrAsync(final AdvertiseByoipCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AdvertiseByoipCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AdvertiseByoipCidrResult call() throws Exception {
                AdvertiseByoipCidrResult result = null;

                try {
                    result = executeAdvertiseByoipCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future allocateAddressAsync(AllocateAddressRequest request) {

        return allocateAddressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future allocateAddressAsync(final AllocateAddressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AllocateAddressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AllocateAddressResult call() throws Exception {
                AllocateAddressResult result = null;

                try {
                    result = executeAllocateAddress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the AllocateAddress operation.
     *
     * @see #allocateAddressAsync(AllocateAddressRequest)
     */
    @Override
    public java.util.concurrent.Future allocateAddressAsync() {

        return allocateAddressAsync(new AllocateAddressRequest());
    }

    /**
     * Simplified method form for invoking the AllocateAddress operation with an AsyncHandler.
     *
     * @see #allocateAddressAsync(AllocateAddressRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future allocateAddressAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return allocateAddressAsync(new AllocateAddressRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future allocateHostsAsync(AllocateHostsRequest request) {

        return allocateHostsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future allocateHostsAsync(final AllocateHostsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AllocateHostsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AllocateHostsResult call() throws Exception {
                AllocateHostsResult result = null;

                try {
                    result = executeAllocateHosts(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future allocateIpamPoolCidrAsync(AllocateIpamPoolCidrRequest request) {

        return allocateIpamPoolCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future allocateIpamPoolCidrAsync(final AllocateIpamPoolCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AllocateIpamPoolCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AllocateIpamPoolCidrResult call() throws Exception {
                AllocateIpamPoolCidrResult result = null;

                try {
                    result = executeAllocateIpamPoolCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future applySecurityGroupsToClientVpnTargetNetworkAsync(
            ApplySecurityGroupsToClientVpnTargetNetworkRequest request) {

        return applySecurityGroupsToClientVpnTargetNetworkAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future applySecurityGroupsToClientVpnTargetNetworkAsync(
            final ApplySecurityGroupsToClientVpnTargetNetworkRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ApplySecurityGroupsToClientVpnTargetNetworkRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ApplySecurityGroupsToClientVpnTargetNetworkResult call() throws Exception {
                ApplySecurityGroupsToClientVpnTargetNetworkResult result = null;

                try {
                    result = executeApplySecurityGroupsToClientVpnTargetNetwork(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future assignIpv6AddressesAsync(AssignIpv6AddressesRequest request) {

        return assignIpv6AddressesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future assignIpv6AddressesAsync(final AssignIpv6AddressesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssignIpv6AddressesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssignIpv6AddressesResult call() throws Exception {
                AssignIpv6AddressesResult result = null;

                try {
                    result = executeAssignIpv6Addresses(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future assignPrivateIpAddressesAsync(AssignPrivateIpAddressesRequest request) {

        return assignPrivateIpAddressesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future assignPrivateIpAddressesAsync(final AssignPrivateIpAddressesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssignPrivateIpAddressesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssignPrivateIpAddressesResult call() throws Exception {
                AssignPrivateIpAddressesResult result = null;

                try {
                    result = executeAssignPrivateIpAddresses(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateAddressAsync(AssociateAddressRequest request) {

        return associateAddressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateAddressAsync(final AssociateAddressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateAddressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateAddressResult call() throws Exception {
                AssociateAddressResult result = null;

                try {
                    result = executeAssociateAddress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateClientVpnTargetNetworkAsync(
            AssociateClientVpnTargetNetworkRequest request) {

        return associateClientVpnTargetNetworkAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateClientVpnTargetNetworkAsync(
            final AssociateClientVpnTargetNetworkRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateClientVpnTargetNetworkRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateClientVpnTargetNetworkResult call() throws Exception {
                AssociateClientVpnTargetNetworkResult result = null;

                try {
                    result = executeAssociateClientVpnTargetNetwork(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateDhcpOptionsAsync(AssociateDhcpOptionsRequest request) {

        return associateDhcpOptionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateDhcpOptionsAsync(final AssociateDhcpOptionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateDhcpOptionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateDhcpOptionsResult call() throws Exception {
                AssociateDhcpOptionsResult result = null;

                try {
                    result = executeAssociateDhcpOptions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateEnclaveCertificateIamRoleAsync(
            AssociateEnclaveCertificateIamRoleRequest request) {

        return associateEnclaveCertificateIamRoleAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateEnclaveCertificateIamRoleAsync(
            final AssociateEnclaveCertificateIamRoleRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateEnclaveCertificateIamRoleRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateEnclaveCertificateIamRoleResult call() throws Exception {
                AssociateEnclaveCertificateIamRoleResult result = null;

                try {
                    result = executeAssociateEnclaveCertificateIamRole(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateIamInstanceProfileAsync(AssociateIamInstanceProfileRequest request) {

        return associateIamInstanceProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateIamInstanceProfileAsync(final AssociateIamInstanceProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateIamInstanceProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateIamInstanceProfileResult call() throws Exception {
                AssociateIamInstanceProfileResult result = null;

                try {
                    result = executeAssociateIamInstanceProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateInstanceEventWindowAsync(AssociateInstanceEventWindowRequest request) {

        return associateInstanceEventWindowAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateInstanceEventWindowAsync(final AssociateInstanceEventWindowRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateInstanceEventWindowRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateInstanceEventWindowResult call() throws Exception {
                AssociateInstanceEventWindowResult result = null;

                try {
                    result = executeAssociateInstanceEventWindow(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateRouteTableAsync(AssociateRouteTableRequest request) {

        return associateRouteTableAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateRouteTableAsync(final AssociateRouteTableRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateRouteTableRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateRouteTableResult call() throws Exception {
                AssociateRouteTableResult result = null;

                try {
                    result = executeAssociateRouteTable(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateSubnetCidrBlockAsync(AssociateSubnetCidrBlockRequest request) {

        return associateSubnetCidrBlockAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateSubnetCidrBlockAsync(final AssociateSubnetCidrBlockRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateSubnetCidrBlockRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateSubnetCidrBlockResult call() throws Exception {
                AssociateSubnetCidrBlockResult result = null;

                try {
                    result = executeAssociateSubnetCidrBlock(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateTransitGatewayMulticastDomainAsync(
            AssociateTransitGatewayMulticastDomainRequest request) {

        return associateTransitGatewayMulticastDomainAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateTransitGatewayMulticastDomainAsync(
            final AssociateTransitGatewayMulticastDomainRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateTransitGatewayMulticastDomainRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateTransitGatewayMulticastDomainResult call() throws Exception {
                AssociateTransitGatewayMulticastDomainResult result = null;

                try {
                    result = executeAssociateTransitGatewayMulticastDomain(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateTransitGatewayRouteTableAsync(
            AssociateTransitGatewayRouteTableRequest request) {

        return associateTransitGatewayRouteTableAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateTransitGatewayRouteTableAsync(
            final AssociateTransitGatewayRouteTableRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateTransitGatewayRouteTableRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateTransitGatewayRouteTableResult call() throws Exception {
                AssociateTransitGatewayRouteTableResult result = null;

                try {
                    result = executeAssociateTransitGatewayRouteTable(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateTrunkInterfaceAsync(AssociateTrunkInterfaceRequest request) {

        return associateTrunkInterfaceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateTrunkInterfaceAsync(final AssociateTrunkInterfaceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateTrunkInterfaceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateTrunkInterfaceResult call() throws Exception {
                AssociateTrunkInterfaceResult result = null;

                try {
                    result = executeAssociateTrunkInterface(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future associateVpcCidrBlockAsync(AssociateVpcCidrBlockRequest request) {

        return associateVpcCidrBlockAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateVpcCidrBlockAsync(final AssociateVpcCidrBlockRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateVpcCidrBlockRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateVpcCidrBlockResult call() throws Exception {
                AssociateVpcCidrBlockResult result = null;

                try {
                    result = executeAssociateVpcCidrBlock(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future attachClassicLinkVpcAsync(AttachClassicLinkVpcRequest request) {

        return attachClassicLinkVpcAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future attachClassicLinkVpcAsync(final AttachClassicLinkVpcRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AttachClassicLinkVpcRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AttachClassicLinkVpcResult call() throws Exception {
                AttachClassicLinkVpcResult result = null;

                try {
                    result = executeAttachClassicLinkVpc(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future attachInternetGatewayAsync(AttachInternetGatewayRequest request) {

        return attachInternetGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future attachInternetGatewayAsync(final AttachInternetGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AttachInternetGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AttachInternetGatewayResult call() throws Exception {
                AttachInternetGatewayResult result = null;

                try {
                    result = executeAttachInternetGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future attachNetworkInterfaceAsync(AttachNetworkInterfaceRequest request) {

        return attachNetworkInterfaceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future attachNetworkInterfaceAsync(final AttachNetworkInterfaceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AttachNetworkInterfaceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AttachNetworkInterfaceResult call() throws Exception {
                AttachNetworkInterfaceResult result = null;

                try {
                    result = executeAttachNetworkInterface(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future attachVolumeAsync(AttachVolumeRequest request) {

        return attachVolumeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future attachVolumeAsync(final AttachVolumeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AttachVolumeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AttachVolumeResult call() throws Exception {
                AttachVolumeResult result = null;

                try {
                    result = executeAttachVolume(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future attachVpnGatewayAsync(AttachVpnGatewayRequest request) {

        return attachVpnGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future attachVpnGatewayAsync(final AttachVpnGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AttachVpnGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AttachVpnGatewayResult call() throws Exception {
                AttachVpnGatewayResult result = null;

                try {
                    result = executeAttachVpnGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future authorizeClientVpnIngressAsync(AuthorizeClientVpnIngressRequest request) {

        return authorizeClientVpnIngressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future authorizeClientVpnIngressAsync(final AuthorizeClientVpnIngressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AuthorizeClientVpnIngressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AuthorizeClientVpnIngressResult call() throws Exception {
                AuthorizeClientVpnIngressResult result = null;

                try {
                    result = executeAuthorizeClientVpnIngress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future authorizeSecurityGroupEgressAsync(AuthorizeSecurityGroupEgressRequest request) {

        return authorizeSecurityGroupEgressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future authorizeSecurityGroupEgressAsync(final AuthorizeSecurityGroupEgressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AuthorizeSecurityGroupEgressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AuthorizeSecurityGroupEgressResult call() throws Exception {
                AuthorizeSecurityGroupEgressResult result = null;

                try {
                    result = executeAuthorizeSecurityGroupEgress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future authorizeSecurityGroupIngressAsync(AuthorizeSecurityGroupIngressRequest request) {

        return authorizeSecurityGroupIngressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future authorizeSecurityGroupIngressAsync(
            final AuthorizeSecurityGroupIngressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AuthorizeSecurityGroupIngressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AuthorizeSecurityGroupIngressResult call() throws Exception {
                AuthorizeSecurityGroupIngressResult result = null;

                try {
                    result = executeAuthorizeSecurityGroupIngress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future bundleInstanceAsync(BundleInstanceRequest request) {

        return bundleInstanceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future bundleInstanceAsync(final BundleInstanceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final BundleInstanceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public BundleInstanceResult call() throws Exception {
                BundleInstanceResult result = null;

                try {
                    result = executeBundleInstance(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future cancelBundleTaskAsync(CancelBundleTaskRequest request) {

        return cancelBundleTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future cancelBundleTaskAsync(final CancelBundleTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CancelBundleTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CancelBundleTaskResult call() throws Exception {
                CancelBundleTaskResult result = null;

                try {
                    result = executeCancelBundleTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future cancelCapacityReservationAsync(CancelCapacityReservationRequest request) {

        return cancelCapacityReservationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future cancelCapacityReservationAsync(final CancelCapacityReservationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CancelCapacityReservationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CancelCapacityReservationResult call() throws Exception {
                CancelCapacityReservationResult result = null;

                try {
                    result = executeCancelCapacityReservation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future cancelCapacityReservationFleetsAsync(
            CancelCapacityReservationFleetsRequest request) {

        return cancelCapacityReservationFleetsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future cancelCapacityReservationFleetsAsync(
            final CancelCapacityReservationFleetsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CancelCapacityReservationFleetsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CancelCapacityReservationFleetsResult call() throws Exception {
                CancelCapacityReservationFleetsResult result = null;

                try {
                    result = executeCancelCapacityReservationFleets(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future cancelConversionTaskAsync(CancelConversionTaskRequest request) {

        return cancelConversionTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future cancelConversionTaskAsync(final CancelConversionTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CancelConversionTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CancelConversionTaskResult call() throws Exception {
                CancelConversionTaskResult result = null;

                try {
                    result = executeCancelConversionTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future cancelExportTaskAsync(CancelExportTaskRequest request) {

        return cancelExportTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future cancelExportTaskAsync(final CancelExportTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CancelExportTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CancelExportTaskResult call() throws Exception {
                CancelExportTaskResult result = null;

                try {
                    result = executeCancelExportTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future cancelImportTaskAsync(CancelImportTaskRequest request) {

        return cancelImportTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future cancelImportTaskAsync(final CancelImportTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CancelImportTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CancelImportTaskResult call() throws Exception {
                CancelImportTaskResult result = null;

                try {
                    result = executeCancelImportTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the CancelImportTask operation.
     *
     * @see #cancelImportTaskAsync(CancelImportTaskRequest)
     */
    @Override
    public java.util.concurrent.Future cancelImportTaskAsync() {

        return cancelImportTaskAsync(new CancelImportTaskRequest());
    }

    /**
     * Simplified method form for invoking the CancelImportTask operation with an AsyncHandler.
     *
     * @see #cancelImportTaskAsync(CancelImportTaskRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future cancelImportTaskAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return cancelImportTaskAsync(new CancelImportTaskRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future cancelReservedInstancesListingAsync(CancelReservedInstancesListingRequest request) {

        return cancelReservedInstancesListingAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future cancelReservedInstancesListingAsync(
            final CancelReservedInstancesListingRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CancelReservedInstancesListingRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CancelReservedInstancesListingResult call() throws Exception {
                CancelReservedInstancesListingResult result = null;

                try {
                    result = executeCancelReservedInstancesListing(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future cancelSpotFleetRequestsAsync(CancelSpotFleetRequestsRequest request) {

        return cancelSpotFleetRequestsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future cancelSpotFleetRequestsAsync(final CancelSpotFleetRequestsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CancelSpotFleetRequestsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CancelSpotFleetRequestsResult call() throws Exception {
                CancelSpotFleetRequestsResult result = null;

                try {
                    result = executeCancelSpotFleetRequests(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future cancelSpotInstanceRequestsAsync(CancelSpotInstanceRequestsRequest request) {

        return cancelSpotInstanceRequestsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future cancelSpotInstanceRequestsAsync(final CancelSpotInstanceRequestsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CancelSpotInstanceRequestsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CancelSpotInstanceRequestsResult call() throws Exception {
                CancelSpotInstanceRequestsResult result = null;

                try {
                    result = executeCancelSpotInstanceRequests(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future confirmProductInstanceAsync(ConfirmProductInstanceRequest request) {

        return confirmProductInstanceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future confirmProductInstanceAsync(final ConfirmProductInstanceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ConfirmProductInstanceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ConfirmProductInstanceResult call() throws Exception {
                ConfirmProductInstanceResult result = null;

                try {
                    result = executeConfirmProductInstance(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future copyFpgaImageAsync(CopyFpgaImageRequest request) {

        return copyFpgaImageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future copyFpgaImageAsync(final CopyFpgaImageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CopyFpgaImageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CopyFpgaImageResult call() throws Exception {
                CopyFpgaImageResult result = null;

                try {
                    result = executeCopyFpgaImage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future copyImageAsync(CopyImageRequest request) {

        return copyImageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future copyImageAsync(final CopyImageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CopyImageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CopyImageResult call() throws Exception {
                CopyImageResult result = null;

                try {
                    result = executeCopyImage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future copySnapshotAsync(CopySnapshotRequest request) {

        return copySnapshotAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future copySnapshotAsync(final CopySnapshotRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CopySnapshotRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CopySnapshotResult call() throws Exception {
                CopySnapshotResult result = null;

                try {
                    result = executeCopySnapshot(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createCapacityReservationAsync(CreateCapacityReservationRequest request) {

        return createCapacityReservationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createCapacityReservationAsync(final CreateCapacityReservationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateCapacityReservationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateCapacityReservationResult call() throws Exception {
                CreateCapacityReservationResult result = null;

                try {
                    result = executeCreateCapacityReservation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createCapacityReservationFleetAsync(CreateCapacityReservationFleetRequest request) {

        return createCapacityReservationFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createCapacityReservationFleetAsync(
            final CreateCapacityReservationFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateCapacityReservationFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateCapacityReservationFleetResult call() throws Exception {
                CreateCapacityReservationFleetResult result = null;

                try {
                    result = executeCreateCapacityReservationFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createCarrierGatewayAsync(CreateCarrierGatewayRequest request) {

        return createCarrierGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createCarrierGatewayAsync(final CreateCarrierGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateCarrierGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateCarrierGatewayResult call() throws Exception {
                CreateCarrierGatewayResult result = null;

                try {
                    result = executeCreateCarrierGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createClientVpnEndpointAsync(CreateClientVpnEndpointRequest request) {

        return createClientVpnEndpointAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createClientVpnEndpointAsync(final CreateClientVpnEndpointRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateClientVpnEndpointRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateClientVpnEndpointResult call() throws Exception {
                CreateClientVpnEndpointResult result = null;

                try {
                    result = executeCreateClientVpnEndpoint(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createClientVpnRouteAsync(CreateClientVpnRouteRequest request) {

        return createClientVpnRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createClientVpnRouteAsync(final CreateClientVpnRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateClientVpnRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateClientVpnRouteResult call() throws Exception {
                CreateClientVpnRouteResult result = null;

                try {
                    result = executeCreateClientVpnRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createCustomerGatewayAsync(CreateCustomerGatewayRequest request) {

        return createCustomerGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createCustomerGatewayAsync(final CreateCustomerGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateCustomerGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateCustomerGatewayResult call() throws Exception {
                CreateCustomerGatewayResult result = null;

                try {
                    result = executeCreateCustomerGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createDefaultSubnetAsync(CreateDefaultSubnetRequest request) {

        return createDefaultSubnetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createDefaultSubnetAsync(final CreateDefaultSubnetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateDefaultSubnetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateDefaultSubnetResult call() throws Exception {
                CreateDefaultSubnetResult result = null;

                try {
                    result = executeCreateDefaultSubnet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createDefaultVpcAsync(CreateDefaultVpcRequest request) {

        return createDefaultVpcAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createDefaultVpcAsync(final CreateDefaultVpcRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateDefaultVpcRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateDefaultVpcResult call() throws Exception {
                CreateDefaultVpcResult result = null;

                try {
                    result = executeCreateDefaultVpc(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createDhcpOptionsAsync(CreateDhcpOptionsRequest request) {

        return createDhcpOptionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createDhcpOptionsAsync(final CreateDhcpOptionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateDhcpOptionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateDhcpOptionsResult call() throws Exception {
                CreateDhcpOptionsResult result = null;

                try {
                    result = executeCreateDhcpOptions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createEgressOnlyInternetGatewayAsync(
            CreateEgressOnlyInternetGatewayRequest request) {

        return createEgressOnlyInternetGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createEgressOnlyInternetGatewayAsync(
            final CreateEgressOnlyInternetGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateEgressOnlyInternetGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateEgressOnlyInternetGatewayResult call() throws Exception {
                CreateEgressOnlyInternetGatewayResult result = null;

                try {
                    result = executeCreateEgressOnlyInternetGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createFleetAsync(CreateFleetRequest request) {

        return createFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createFleetAsync(final CreateFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateFleetResult call() throws Exception {
                CreateFleetResult result = null;

                try {
                    result = executeCreateFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createFlowLogsAsync(CreateFlowLogsRequest request) {

        return createFlowLogsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createFlowLogsAsync(final CreateFlowLogsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateFlowLogsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateFlowLogsResult call() throws Exception {
                CreateFlowLogsResult result = null;

                try {
                    result = executeCreateFlowLogs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createFpgaImageAsync(CreateFpgaImageRequest request) {

        return createFpgaImageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createFpgaImageAsync(final CreateFpgaImageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateFpgaImageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateFpgaImageResult call() throws Exception {
                CreateFpgaImageResult result = null;

                try {
                    result = executeCreateFpgaImage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createImageAsync(CreateImageRequest request) {

        return createImageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createImageAsync(final CreateImageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateImageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateImageResult call() throws Exception {
                CreateImageResult result = null;

                try {
                    result = executeCreateImage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createInstanceEventWindowAsync(CreateInstanceEventWindowRequest request) {

        return createInstanceEventWindowAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createInstanceEventWindowAsync(final CreateInstanceEventWindowRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateInstanceEventWindowRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateInstanceEventWindowResult call() throws Exception {
                CreateInstanceEventWindowResult result = null;

                try {
                    result = executeCreateInstanceEventWindow(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createInstanceExportTaskAsync(CreateInstanceExportTaskRequest request) {

        return createInstanceExportTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createInstanceExportTaskAsync(final CreateInstanceExportTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateInstanceExportTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateInstanceExportTaskResult call() throws Exception {
                CreateInstanceExportTaskResult result = null;

                try {
                    result = executeCreateInstanceExportTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createInternetGatewayAsync(CreateInternetGatewayRequest request) {

        return createInternetGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createInternetGatewayAsync(final CreateInternetGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateInternetGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateInternetGatewayResult call() throws Exception {
                CreateInternetGatewayResult result = null;

                try {
                    result = executeCreateInternetGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the CreateInternetGateway operation.
     *
     * @see #createInternetGatewayAsync(CreateInternetGatewayRequest)
     */
    @Override
    public java.util.concurrent.Future createInternetGatewayAsync() {

        return createInternetGatewayAsync(new CreateInternetGatewayRequest());
    }

    /**
     * Simplified method form for invoking the CreateInternetGateway operation with an AsyncHandler.
     *
     * @see #createInternetGatewayAsync(CreateInternetGatewayRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future createInternetGatewayAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return createInternetGatewayAsync(new CreateInternetGatewayRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future createIpamAsync(CreateIpamRequest request) {

        return createIpamAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createIpamAsync(final CreateIpamRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateIpamRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateIpamResult call() throws Exception {
                CreateIpamResult result = null;

                try {
                    result = executeCreateIpam(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createIpamPoolAsync(CreateIpamPoolRequest request) {

        return createIpamPoolAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createIpamPoolAsync(final CreateIpamPoolRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateIpamPoolRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateIpamPoolResult call() throws Exception {
                CreateIpamPoolResult result = null;

                try {
                    result = executeCreateIpamPool(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createIpamScopeAsync(CreateIpamScopeRequest request) {

        return createIpamScopeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createIpamScopeAsync(final CreateIpamScopeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateIpamScopeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateIpamScopeResult call() throws Exception {
                CreateIpamScopeResult result = null;

                try {
                    result = executeCreateIpamScope(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createKeyPairAsync(CreateKeyPairRequest request) {

        return createKeyPairAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createKeyPairAsync(final CreateKeyPairRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateKeyPairRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateKeyPairResult call() throws Exception {
                CreateKeyPairResult result = null;

                try {
                    result = executeCreateKeyPair(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createLaunchTemplateAsync(CreateLaunchTemplateRequest request) {

        return createLaunchTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createLaunchTemplateAsync(final CreateLaunchTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateLaunchTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateLaunchTemplateResult call() throws Exception {
                CreateLaunchTemplateResult result = null;

                try {
                    result = executeCreateLaunchTemplate(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createLaunchTemplateVersionAsync(CreateLaunchTemplateVersionRequest request) {

        return createLaunchTemplateVersionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createLaunchTemplateVersionAsync(final CreateLaunchTemplateVersionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateLaunchTemplateVersionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateLaunchTemplateVersionResult call() throws Exception {
                CreateLaunchTemplateVersionResult result = null;

                try {
                    result = executeCreateLaunchTemplateVersion(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createLocalGatewayRouteAsync(CreateLocalGatewayRouteRequest request) {

        return createLocalGatewayRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createLocalGatewayRouteAsync(final CreateLocalGatewayRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateLocalGatewayRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateLocalGatewayRouteResult call() throws Exception {
                CreateLocalGatewayRouteResult result = null;

                try {
                    result = executeCreateLocalGatewayRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createLocalGatewayRouteTableVpcAssociationAsync(
            CreateLocalGatewayRouteTableVpcAssociationRequest request) {

        return createLocalGatewayRouteTableVpcAssociationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createLocalGatewayRouteTableVpcAssociationAsync(
            final CreateLocalGatewayRouteTableVpcAssociationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateLocalGatewayRouteTableVpcAssociationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateLocalGatewayRouteTableVpcAssociationResult call() throws Exception {
                CreateLocalGatewayRouteTableVpcAssociationResult result = null;

                try {
                    result = executeCreateLocalGatewayRouteTableVpcAssociation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createManagedPrefixListAsync(CreateManagedPrefixListRequest request) {

        return createManagedPrefixListAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createManagedPrefixListAsync(final CreateManagedPrefixListRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateManagedPrefixListRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateManagedPrefixListResult call() throws Exception {
                CreateManagedPrefixListResult result = null;

                try {
                    result = executeCreateManagedPrefixList(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createNatGatewayAsync(CreateNatGatewayRequest request) {

        return createNatGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createNatGatewayAsync(final CreateNatGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateNatGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateNatGatewayResult call() throws Exception {
                CreateNatGatewayResult result = null;

                try {
                    result = executeCreateNatGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createNetworkAclAsync(CreateNetworkAclRequest request) {

        return createNetworkAclAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createNetworkAclAsync(final CreateNetworkAclRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateNetworkAclRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateNetworkAclResult call() throws Exception {
                CreateNetworkAclResult result = null;

                try {
                    result = executeCreateNetworkAcl(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createNetworkAclEntryAsync(CreateNetworkAclEntryRequest request) {

        return createNetworkAclEntryAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createNetworkAclEntryAsync(final CreateNetworkAclEntryRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateNetworkAclEntryRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateNetworkAclEntryResult call() throws Exception {
                CreateNetworkAclEntryResult result = null;

                try {
                    result = executeCreateNetworkAclEntry(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createNetworkInsightsAccessScopeAsync(
            CreateNetworkInsightsAccessScopeRequest request) {

        return createNetworkInsightsAccessScopeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createNetworkInsightsAccessScopeAsync(
            final CreateNetworkInsightsAccessScopeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateNetworkInsightsAccessScopeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateNetworkInsightsAccessScopeResult call() throws Exception {
                CreateNetworkInsightsAccessScopeResult result = null;

                try {
                    result = executeCreateNetworkInsightsAccessScope(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createNetworkInsightsPathAsync(CreateNetworkInsightsPathRequest request) {

        return createNetworkInsightsPathAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createNetworkInsightsPathAsync(final CreateNetworkInsightsPathRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateNetworkInsightsPathRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateNetworkInsightsPathResult call() throws Exception {
                CreateNetworkInsightsPathResult result = null;

                try {
                    result = executeCreateNetworkInsightsPath(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createNetworkInterfaceAsync(CreateNetworkInterfaceRequest request) {

        return createNetworkInterfaceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createNetworkInterfaceAsync(final CreateNetworkInterfaceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateNetworkInterfaceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateNetworkInterfaceResult call() throws Exception {
                CreateNetworkInterfaceResult result = null;

                try {
                    result = executeCreateNetworkInterface(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createNetworkInterfacePermissionAsync(
            CreateNetworkInterfacePermissionRequest request) {

        return createNetworkInterfacePermissionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createNetworkInterfacePermissionAsync(
            final CreateNetworkInterfacePermissionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateNetworkInterfacePermissionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateNetworkInterfacePermissionResult call() throws Exception {
                CreateNetworkInterfacePermissionResult result = null;

                try {
                    result = executeCreateNetworkInterfacePermission(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createPlacementGroupAsync(CreatePlacementGroupRequest request) {

        return createPlacementGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createPlacementGroupAsync(final CreatePlacementGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreatePlacementGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreatePlacementGroupResult call() throws Exception {
                CreatePlacementGroupResult result = null;

                try {
                    result = executeCreatePlacementGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createPublicIpv4PoolAsync(CreatePublicIpv4PoolRequest request) {

        return createPublicIpv4PoolAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createPublicIpv4PoolAsync(final CreatePublicIpv4PoolRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreatePublicIpv4PoolRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreatePublicIpv4PoolResult call() throws Exception {
                CreatePublicIpv4PoolResult result = null;

                try {
                    result = executeCreatePublicIpv4Pool(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createReplaceRootVolumeTaskAsync(CreateReplaceRootVolumeTaskRequest request) {

        return createReplaceRootVolumeTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createReplaceRootVolumeTaskAsync(final CreateReplaceRootVolumeTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateReplaceRootVolumeTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateReplaceRootVolumeTaskResult call() throws Exception {
                CreateReplaceRootVolumeTaskResult result = null;

                try {
                    result = executeCreateReplaceRootVolumeTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createReservedInstancesListingAsync(CreateReservedInstancesListingRequest request) {

        return createReservedInstancesListingAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createReservedInstancesListingAsync(
            final CreateReservedInstancesListingRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateReservedInstancesListingRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateReservedInstancesListingResult call() throws Exception {
                CreateReservedInstancesListingResult result = null;

                try {
                    result = executeCreateReservedInstancesListing(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createRestoreImageTaskAsync(CreateRestoreImageTaskRequest request) {

        return createRestoreImageTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createRestoreImageTaskAsync(final CreateRestoreImageTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateRestoreImageTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateRestoreImageTaskResult call() throws Exception {
                CreateRestoreImageTaskResult result = null;

                try {
                    result = executeCreateRestoreImageTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createRouteAsync(CreateRouteRequest request) {

        return createRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createRouteAsync(final CreateRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateRouteResult call() throws Exception {
                CreateRouteResult result = null;

                try {
                    result = executeCreateRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createRouteTableAsync(CreateRouteTableRequest request) {

        return createRouteTableAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createRouteTableAsync(final CreateRouteTableRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateRouteTableRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateRouteTableResult call() throws Exception {
                CreateRouteTableResult result = null;

                try {
                    result = executeCreateRouteTable(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createSecurityGroupAsync(CreateSecurityGroupRequest request) {

        return createSecurityGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createSecurityGroupAsync(final CreateSecurityGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateSecurityGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateSecurityGroupResult call() throws Exception {
                CreateSecurityGroupResult result = null;

                try {
                    result = executeCreateSecurityGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createSnapshotAsync(CreateSnapshotRequest request) {

        return createSnapshotAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createSnapshotAsync(final CreateSnapshotRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateSnapshotRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateSnapshotResult call() throws Exception {
                CreateSnapshotResult result = null;

                try {
                    result = executeCreateSnapshot(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createSnapshotsAsync(CreateSnapshotsRequest request) {

        return createSnapshotsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createSnapshotsAsync(final CreateSnapshotsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateSnapshotsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateSnapshotsResult call() throws Exception {
                CreateSnapshotsResult result = null;

                try {
                    result = executeCreateSnapshots(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createSpotDatafeedSubscriptionAsync(CreateSpotDatafeedSubscriptionRequest request) {

        return createSpotDatafeedSubscriptionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createSpotDatafeedSubscriptionAsync(
            final CreateSpotDatafeedSubscriptionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateSpotDatafeedSubscriptionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateSpotDatafeedSubscriptionResult call() throws Exception {
                CreateSpotDatafeedSubscriptionResult result = null;

                try {
                    result = executeCreateSpotDatafeedSubscription(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createStoreImageTaskAsync(CreateStoreImageTaskRequest request) {

        return createStoreImageTaskAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createStoreImageTaskAsync(final CreateStoreImageTaskRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateStoreImageTaskRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateStoreImageTaskResult call() throws Exception {
                CreateStoreImageTaskResult result = null;

                try {
                    result = executeCreateStoreImageTask(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createSubnetAsync(CreateSubnetRequest request) {

        return createSubnetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createSubnetAsync(final CreateSubnetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateSubnetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateSubnetResult call() throws Exception {
                CreateSubnetResult result = null;

                try {
                    result = executeCreateSubnet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createSubnetCidrReservationAsync(CreateSubnetCidrReservationRequest request) {

        return createSubnetCidrReservationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createSubnetCidrReservationAsync(final CreateSubnetCidrReservationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateSubnetCidrReservationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateSubnetCidrReservationResult call() throws Exception {
                CreateSubnetCidrReservationResult result = null;

                try {
                    result = executeCreateSubnetCidrReservation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTagsAsync(CreateTagsRequest request) {

        return createTagsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTagsAsync(final CreateTagsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTagsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTagsResult call() throws Exception {
                CreateTagsResult result = null;

                try {
                    result = executeCreateTags(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTrafficMirrorFilterAsync(CreateTrafficMirrorFilterRequest request) {

        return createTrafficMirrorFilterAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTrafficMirrorFilterAsync(final CreateTrafficMirrorFilterRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTrafficMirrorFilterRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTrafficMirrorFilterResult call() throws Exception {
                CreateTrafficMirrorFilterResult result = null;

                try {
                    result = executeCreateTrafficMirrorFilter(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTrafficMirrorFilterRuleAsync(CreateTrafficMirrorFilterRuleRequest request) {

        return createTrafficMirrorFilterRuleAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTrafficMirrorFilterRuleAsync(
            final CreateTrafficMirrorFilterRuleRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTrafficMirrorFilterRuleRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTrafficMirrorFilterRuleResult call() throws Exception {
                CreateTrafficMirrorFilterRuleResult result = null;

                try {
                    result = executeCreateTrafficMirrorFilterRule(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTrafficMirrorSessionAsync(CreateTrafficMirrorSessionRequest request) {

        return createTrafficMirrorSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTrafficMirrorSessionAsync(final CreateTrafficMirrorSessionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTrafficMirrorSessionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTrafficMirrorSessionResult call() throws Exception {
                CreateTrafficMirrorSessionResult result = null;

                try {
                    result = executeCreateTrafficMirrorSession(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTrafficMirrorTargetAsync(CreateTrafficMirrorTargetRequest request) {

        return createTrafficMirrorTargetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTrafficMirrorTargetAsync(final CreateTrafficMirrorTargetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTrafficMirrorTargetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTrafficMirrorTargetResult call() throws Exception {
                CreateTrafficMirrorTargetResult result = null;

                try {
                    result = executeCreateTrafficMirrorTarget(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayAsync(CreateTransitGatewayRequest request) {

        return createTransitGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayAsync(final CreateTransitGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTransitGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTransitGatewayResult call() throws Exception {
                CreateTransitGatewayResult result = null;

                try {
                    result = executeCreateTransitGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayConnectAsync(CreateTransitGatewayConnectRequest request) {

        return createTransitGatewayConnectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayConnectAsync(final CreateTransitGatewayConnectRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTransitGatewayConnectRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTransitGatewayConnectResult call() throws Exception {
                CreateTransitGatewayConnectResult result = null;

                try {
                    result = executeCreateTransitGatewayConnect(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayConnectPeerAsync(
            CreateTransitGatewayConnectPeerRequest request) {

        return createTransitGatewayConnectPeerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayConnectPeerAsync(
            final CreateTransitGatewayConnectPeerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTransitGatewayConnectPeerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTransitGatewayConnectPeerResult call() throws Exception {
                CreateTransitGatewayConnectPeerResult result = null;

                try {
                    result = executeCreateTransitGatewayConnectPeer(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayMulticastDomainAsync(
            CreateTransitGatewayMulticastDomainRequest request) {

        return createTransitGatewayMulticastDomainAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayMulticastDomainAsync(
            final CreateTransitGatewayMulticastDomainRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTransitGatewayMulticastDomainRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTransitGatewayMulticastDomainResult call() throws Exception {
                CreateTransitGatewayMulticastDomainResult result = null;

                try {
                    result = executeCreateTransitGatewayMulticastDomain(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayPeeringAttachmentAsync(
            CreateTransitGatewayPeeringAttachmentRequest request) {

        return createTransitGatewayPeeringAttachmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayPeeringAttachmentAsync(
            final CreateTransitGatewayPeeringAttachmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTransitGatewayPeeringAttachmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTransitGatewayPeeringAttachmentResult call() throws Exception {
                CreateTransitGatewayPeeringAttachmentResult result = null;

                try {
                    result = executeCreateTransitGatewayPeeringAttachment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayPrefixListReferenceAsync(
            CreateTransitGatewayPrefixListReferenceRequest request) {

        return createTransitGatewayPrefixListReferenceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayPrefixListReferenceAsync(
            final CreateTransitGatewayPrefixListReferenceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTransitGatewayPrefixListReferenceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTransitGatewayPrefixListReferenceResult call() throws Exception {
                CreateTransitGatewayPrefixListReferenceResult result = null;

                try {
                    result = executeCreateTransitGatewayPrefixListReference(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayRouteAsync(CreateTransitGatewayRouteRequest request) {

        return createTransitGatewayRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayRouteAsync(final CreateTransitGatewayRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTransitGatewayRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTransitGatewayRouteResult call() throws Exception {
                CreateTransitGatewayRouteResult result = null;

                try {
                    result = executeCreateTransitGatewayRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayRouteTableAsync(CreateTransitGatewayRouteTableRequest request) {

        return createTransitGatewayRouteTableAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayRouteTableAsync(
            final CreateTransitGatewayRouteTableRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTransitGatewayRouteTableRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTransitGatewayRouteTableResult call() throws Exception {
                CreateTransitGatewayRouteTableResult result = null;

                try {
                    result = executeCreateTransitGatewayRouteTable(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayVpcAttachmentAsync(
            CreateTransitGatewayVpcAttachmentRequest request) {

        return createTransitGatewayVpcAttachmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTransitGatewayVpcAttachmentAsync(
            final CreateTransitGatewayVpcAttachmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTransitGatewayVpcAttachmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTransitGatewayVpcAttachmentResult call() throws Exception {
                CreateTransitGatewayVpcAttachmentResult result = null;

                try {
                    result = executeCreateTransitGatewayVpcAttachment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createVolumeAsync(CreateVolumeRequest request) {

        return createVolumeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createVolumeAsync(final CreateVolumeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateVolumeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateVolumeResult call() throws Exception {
                CreateVolumeResult result = null;

                try {
                    result = executeCreateVolume(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createVpcAsync(CreateVpcRequest request) {

        return createVpcAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createVpcAsync(final CreateVpcRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateVpcRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateVpcResult call() throws Exception {
                CreateVpcResult result = null;

                try {
                    result = executeCreateVpc(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createVpcEndpointAsync(CreateVpcEndpointRequest request) {

        return createVpcEndpointAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createVpcEndpointAsync(final CreateVpcEndpointRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateVpcEndpointRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateVpcEndpointResult call() throws Exception {
                CreateVpcEndpointResult result = null;

                try {
                    result = executeCreateVpcEndpoint(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createVpcEndpointConnectionNotificationAsync(
            CreateVpcEndpointConnectionNotificationRequest request) {

        return createVpcEndpointConnectionNotificationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createVpcEndpointConnectionNotificationAsync(
            final CreateVpcEndpointConnectionNotificationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateVpcEndpointConnectionNotificationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateVpcEndpointConnectionNotificationResult call() throws Exception {
                CreateVpcEndpointConnectionNotificationResult result = null;

                try {
                    result = executeCreateVpcEndpointConnectionNotification(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createVpcEndpointServiceConfigurationAsync(
            CreateVpcEndpointServiceConfigurationRequest request) {

        return createVpcEndpointServiceConfigurationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createVpcEndpointServiceConfigurationAsync(
            final CreateVpcEndpointServiceConfigurationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateVpcEndpointServiceConfigurationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateVpcEndpointServiceConfigurationResult call() throws Exception {
                CreateVpcEndpointServiceConfigurationResult result = null;

                try {
                    result = executeCreateVpcEndpointServiceConfiguration(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createVpcPeeringConnectionAsync(CreateVpcPeeringConnectionRequest request) {

        return createVpcPeeringConnectionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createVpcPeeringConnectionAsync(final CreateVpcPeeringConnectionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateVpcPeeringConnectionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateVpcPeeringConnectionResult call() throws Exception {
                CreateVpcPeeringConnectionResult result = null;

                try {
                    result = executeCreateVpcPeeringConnection(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the CreateVpcPeeringConnection operation.
     *
     * @see #createVpcPeeringConnectionAsync(CreateVpcPeeringConnectionRequest)
     */
    @Override
    public java.util.concurrent.Future createVpcPeeringConnectionAsync() {

        return createVpcPeeringConnectionAsync(new CreateVpcPeeringConnectionRequest());
    }

    /**
     * Simplified method form for invoking the CreateVpcPeeringConnection operation with an AsyncHandler.
     *
     * @see #createVpcPeeringConnectionAsync(CreateVpcPeeringConnectionRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future createVpcPeeringConnectionAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return createVpcPeeringConnectionAsync(new CreateVpcPeeringConnectionRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future createVpnConnectionAsync(CreateVpnConnectionRequest request) {

        return createVpnConnectionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createVpnConnectionAsync(final CreateVpnConnectionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateVpnConnectionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateVpnConnectionResult call() throws Exception {
                CreateVpnConnectionResult result = null;

                try {
                    result = executeCreateVpnConnection(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createVpnConnectionRouteAsync(CreateVpnConnectionRouteRequest request) {

        return createVpnConnectionRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createVpnConnectionRouteAsync(final CreateVpnConnectionRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateVpnConnectionRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateVpnConnectionRouteResult call() throws Exception {
                CreateVpnConnectionRouteResult result = null;

                try {
                    result = executeCreateVpnConnectionRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future createVpnGatewayAsync(CreateVpnGatewayRequest request) {

        return createVpnGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createVpnGatewayAsync(final CreateVpnGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateVpnGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateVpnGatewayResult call() throws Exception {
                CreateVpnGatewayResult result = null;

                try {
                    result = executeCreateVpnGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteCarrierGatewayAsync(DeleteCarrierGatewayRequest request) {

        return deleteCarrierGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteCarrierGatewayAsync(final DeleteCarrierGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteCarrierGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteCarrierGatewayResult call() throws Exception {
                DeleteCarrierGatewayResult result = null;

                try {
                    result = executeDeleteCarrierGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteClientVpnEndpointAsync(DeleteClientVpnEndpointRequest request) {

        return deleteClientVpnEndpointAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteClientVpnEndpointAsync(final DeleteClientVpnEndpointRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteClientVpnEndpointRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteClientVpnEndpointResult call() throws Exception {
                DeleteClientVpnEndpointResult result = null;

                try {
                    result = executeDeleteClientVpnEndpoint(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteClientVpnRouteAsync(DeleteClientVpnRouteRequest request) {

        return deleteClientVpnRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteClientVpnRouteAsync(final DeleteClientVpnRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteClientVpnRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteClientVpnRouteResult call() throws Exception {
                DeleteClientVpnRouteResult result = null;

                try {
                    result = executeDeleteClientVpnRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteCustomerGatewayAsync(DeleteCustomerGatewayRequest request) {

        return deleteCustomerGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteCustomerGatewayAsync(final DeleteCustomerGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteCustomerGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteCustomerGatewayResult call() throws Exception {
                DeleteCustomerGatewayResult result = null;

                try {
                    result = executeDeleteCustomerGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteDhcpOptionsAsync(DeleteDhcpOptionsRequest request) {

        return deleteDhcpOptionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteDhcpOptionsAsync(final DeleteDhcpOptionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteDhcpOptionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteDhcpOptionsResult call() throws Exception {
                DeleteDhcpOptionsResult result = null;

                try {
                    result = executeDeleteDhcpOptions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteEgressOnlyInternetGatewayAsync(
            DeleteEgressOnlyInternetGatewayRequest request) {

        return deleteEgressOnlyInternetGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteEgressOnlyInternetGatewayAsync(
            final DeleteEgressOnlyInternetGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteEgressOnlyInternetGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteEgressOnlyInternetGatewayResult call() throws Exception {
                DeleteEgressOnlyInternetGatewayResult result = null;

                try {
                    result = executeDeleteEgressOnlyInternetGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteFleetsAsync(DeleteFleetsRequest request) {

        return deleteFleetsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteFleetsAsync(final DeleteFleetsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteFleetsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteFleetsResult call() throws Exception {
                DeleteFleetsResult result = null;

                try {
                    result = executeDeleteFleets(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteFlowLogsAsync(DeleteFlowLogsRequest request) {

        return deleteFlowLogsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteFlowLogsAsync(final DeleteFlowLogsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteFlowLogsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteFlowLogsResult call() throws Exception {
                DeleteFlowLogsResult result = null;

                try {
                    result = executeDeleteFlowLogs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteFpgaImageAsync(DeleteFpgaImageRequest request) {

        return deleteFpgaImageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteFpgaImageAsync(final DeleteFpgaImageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteFpgaImageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteFpgaImageResult call() throws Exception {
                DeleteFpgaImageResult result = null;

                try {
                    result = executeDeleteFpgaImage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteInstanceEventWindowAsync(DeleteInstanceEventWindowRequest request) {

        return deleteInstanceEventWindowAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteInstanceEventWindowAsync(final DeleteInstanceEventWindowRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteInstanceEventWindowRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteInstanceEventWindowResult call() throws Exception {
                DeleteInstanceEventWindowResult result = null;

                try {
                    result = executeDeleteInstanceEventWindow(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteInternetGatewayAsync(DeleteInternetGatewayRequest request) {

        return deleteInternetGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteInternetGatewayAsync(final DeleteInternetGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteInternetGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteInternetGatewayResult call() throws Exception {
                DeleteInternetGatewayResult result = null;

                try {
                    result = executeDeleteInternetGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteIpamAsync(DeleteIpamRequest request) {

        return deleteIpamAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteIpamAsync(final DeleteIpamRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteIpamRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteIpamResult call() throws Exception {
                DeleteIpamResult result = null;

                try {
                    result = executeDeleteIpam(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteIpamPoolAsync(DeleteIpamPoolRequest request) {

        return deleteIpamPoolAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteIpamPoolAsync(final DeleteIpamPoolRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteIpamPoolRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteIpamPoolResult call() throws Exception {
                DeleteIpamPoolResult result = null;

                try {
                    result = executeDeleteIpamPool(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteIpamScopeAsync(DeleteIpamScopeRequest request) {

        return deleteIpamScopeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteIpamScopeAsync(final DeleteIpamScopeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteIpamScopeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteIpamScopeResult call() throws Exception {
                DeleteIpamScopeResult result = null;

                try {
                    result = executeDeleteIpamScope(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteKeyPairAsync(DeleteKeyPairRequest request) {

        return deleteKeyPairAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteKeyPairAsync(final DeleteKeyPairRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteKeyPairRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteKeyPairResult call() throws Exception {
                DeleteKeyPairResult result = null;

                try {
                    result = executeDeleteKeyPair(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteLaunchTemplateAsync(DeleteLaunchTemplateRequest request) {

        return deleteLaunchTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteLaunchTemplateAsync(final DeleteLaunchTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteLaunchTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteLaunchTemplateResult call() throws Exception {
                DeleteLaunchTemplateResult result = null;

                try {
                    result = executeDeleteLaunchTemplate(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteLaunchTemplateVersionsAsync(DeleteLaunchTemplateVersionsRequest request) {

        return deleteLaunchTemplateVersionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteLaunchTemplateVersionsAsync(final DeleteLaunchTemplateVersionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteLaunchTemplateVersionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteLaunchTemplateVersionsResult call() throws Exception {
                DeleteLaunchTemplateVersionsResult result = null;

                try {
                    result = executeDeleteLaunchTemplateVersions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteLocalGatewayRouteAsync(DeleteLocalGatewayRouteRequest request) {

        return deleteLocalGatewayRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteLocalGatewayRouteAsync(final DeleteLocalGatewayRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteLocalGatewayRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteLocalGatewayRouteResult call() throws Exception {
                DeleteLocalGatewayRouteResult result = null;

                try {
                    result = executeDeleteLocalGatewayRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteLocalGatewayRouteTableVpcAssociationAsync(
            DeleteLocalGatewayRouteTableVpcAssociationRequest request) {

        return deleteLocalGatewayRouteTableVpcAssociationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteLocalGatewayRouteTableVpcAssociationAsync(
            final DeleteLocalGatewayRouteTableVpcAssociationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteLocalGatewayRouteTableVpcAssociationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteLocalGatewayRouteTableVpcAssociationResult call() throws Exception {
                DeleteLocalGatewayRouteTableVpcAssociationResult result = null;

                try {
                    result = executeDeleteLocalGatewayRouteTableVpcAssociation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteManagedPrefixListAsync(DeleteManagedPrefixListRequest request) {

        return deleteManagedPrefixListAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteManagedPrefixListAsync(final DeleteManagedPrefixListRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteManagedPrefixListRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteManagedPrefixListResult call() throws Exception {
                DeleteManagedPrefixListResult result = null;

                try {
                    result = executeDeleteManagedPrefixList(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteNatGatewayAsync(DeleteNatGatewayRequest request) {

        return deleteNatGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteNatGatewayAsync(final DeleteNatGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteNatGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteNatGatewayResult call() throws Exception {
                DeleteNatGatewayResult result = null;

                try {
                    result = executeDeleteNatGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteNetworkAclAsync(DeleteNetworkAclRequest request) {

        return deleteNetworkAclAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteNetworkAclAsync(final DeleteNetworkAclRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteNetworkAclRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteNetworkAclResult call() throws Exception {
                DeleteNetworkAclResult result = null;

                try {
                    result = executeDeleteNetworkAcl(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteNetworkAclEntryAsync(DeleteNetworkAclEntryRequest request) {

        return deleteNetworkAclEntryAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteNetworkAclEntryAsync(final DeleteNetworkAclEntryRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteNetworkAclEntryRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteNetworkAclEntryResult call() throws Exception {
                DeleteNetworkAclEntryResult result = null;

                try {
                    result = executeDeleteNetworkAclEntry(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInsightsAccessScopeAsync(
            DeleteNetworkInsightsAccessScopeRequest request) {

        return deleteNetworkInsightsAccessScopeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInsightsAccessScopeAsync(
            final DeleteNetworkInsightsAccessScopeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteNetworkInsightsAccessScopeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteNetworkInsightsAccessScopeResult call() throws Exception {
                DeleteNetworkInsightsAccessScopeResult result = null;

                try {
                    result = executeDeleteNetworkInsightsAccessScope(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInsightsAccessScopeAnalysisAsync(
            DeleteNetworkInsightsAccessScopeAnalysisRequest request) {

        return deleteNetworkInsightsAccessScopeAnalysisAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInsightsAccessScopeAnalysisAsync(
            final DeleteNetworkInsightsAccessScopeAnalysisRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteNetworkInsightsAccessScopeAnalysisRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteNetworkInsightsAccessScopeAnalysisResult call() throws Exception {
                DeleteNetworkInsightsAccessScopeAnalysisResult result = null;

                try {
                    result = executeDeleteNetworkInsightsAccessScopeAnalysis(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInsightsAnalysisAsync(DeleteNetworkInsightsAnalysisRequest request) {

        return deleteNetworkInsightsAnalysisAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInsightsAnalysisAsync(
            final DeleteNetworkInsightsAnalysisRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteNetworkInsightsAnalysisRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteNetworkInsightsAnalysisResult call() throws Exception {
                DeleteNetworkInsightsAnalysisResult result = null;

                try {
                    result = executeDeleteNetworkInsightsAnalysis(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInsightsPathAsync(DeleteNetworkInsightsPathRequest request) {

        return deleteNetworkInsightsPathAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInsightsPathAsync(final DeleteNetworkInsightsPathRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteNetworkInsightsPathRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteNetworkInsightsPathResult call() throws Exception {
                DeleteNetworkInsightsPathResult result = null;

                try {
                    result = executeDeleteNetworkInsightsPath(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInterfaceAsync(DeleteNetworkInterfaceRequest request) {

        return deleteNetworkInterfaceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInterfaceAsync(final DeleteNetworkInterfaceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteNetworkInterfaceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteNetworkInterfaceResult call() throws Exception {
                DeleteNetworkInterfaceResult result = null;

                try {
                    result = executeDeleteNetworkInterface(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInterfacePermissionAsync(
            DeleteNetworkInterfacePermissionRequest request) {

        return deleteNetworkInterfacePermissionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteNetworkInterfacePermissionAsync(
            final DeleteNetworkInterfacePermissionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteNetworkInterfacePermissionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteNetworkInterfacePermissionResult call() throws Exception {
                DeleteNetworkInterfacePermissionResult result = null;

                try {
                    result = executeDeleteNetworkInterfacePermission(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deletePlacementGroupAsync(DeletePlacementGroupRequest request) {

        return deletePlacementGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deletePlacementGroupAsync(final DeletePlacementGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeletePlacementGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeletePlacementGroupResult call() throws Exception {
                DeletePlacementGroupResult result = null;

                try {
                    result = executeDeletePlacementGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deletePublicIpv4PoolAsync(DeletePublicIpv4PoolRequest request) {

        return deletePublicIpv4PoolAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deletePublicIpv4PoolAsync(final DeletePublicIpv4PoolRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeletePublicIpv4PoolRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeletePublicIpv4PoolResult call() throws Exception {
                DeletePublicIpv4PoolResult result = null;

                try {
                    result = executeDeletePublicIpv4Pool(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteQueuedReservedInstancesAsync(DeleteQueuedReservedInstancesRequest request) {

        return deleteQueuedReservedInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteQueuedReservedInstancesAsync(
            final DeleteQueuedReservedInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteQueuedReservedInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteQueuedReservedInstancesResult call() throws Exception {
                DeleteQueuedReservedInstancesResult result = null;

                try {
                    result = executeDeleteQueuedReservedInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteRouteAsync(DeleteRouteRequest request) {

        return deleteRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteRouteAsync(final DeleteRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteRouteResult call() throws Exception {
                DeleteRouteResult result = null;

                try {
                    result = executeDeleteRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteRouteTableAsync(DeleteRouteTableRequest request) {

        return deleteRouteTableAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteRouteTableAsync(final DeleteRouteTableRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteRouteTableRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteRouteTableResult call() throws Exception {
                DeleteRouteTableResult result = null;

                try {
                    result = executeDeleteRouteTable(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteSecurityGroupAsync(DeleteSecurityGroupRequest request) {

        return deleteSecurityGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteSecurityGroupAsync(final DeleteSecurityGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteSecurityGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteSecurityGroupResult call() throws Exception {
                DeleteSecurityGroupResult result = null;

                try {
                    result = executeDeleteSecurityGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteSnapshotAsync(DeleteSnapshotRequest request) {

        return deleteSnapshotAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteSnapshotAsync(final DeleteSnapshotRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteSnapshotRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteSnapshotResult call() throws Exception {
                DeleteSnapshotResult result = null;

                try {
                    result = executeDeleteSnapshot(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteSpotDatafeedSubscriptionAsync(DeleteSpotDatafeedSubscriptionRequest request) {

        return deleteSpotDatafeedSubscriptionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteSpotDatafeedSubscriptionAsync(
            final DeleteSpotDatafeedSubscriptionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteSpotDatafeedSubscriptionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteSpotDatafeedSubscriptionResult call() throws Exception {
                DeleteSpotDatafeedSubscriptionResult result = null;

                try {
                    result = executeDeleteSpotDatafeedSubscription(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DeleteSpotDatafeedSubscription operation.
     *
     * @see #deleteSpotDatafeedSubscriptionAsync(DeleteSpotDatafeedSubscriptionRequest)
     */
    @Override
    public java.util.concurrent.Future deleteSpotDatafeedSubscriptionAsync() {

        return deleteSpotDatafeedSubscriptionAsync(new DeleteSpotDatafeedSubscriptionRequest());
    }

    /**
     * Simplified method form for invoking the DeleteSpotDatafeedSubscription operation with an AsyncHandler.
     *
     * @see #deleteSpotDatafeedSubscriptionAsync(DeleteSpotDatafeedSubscriptionRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future deleteSpotDatafeedSubscriptionAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return deleteSpotDatafeedSubscriptionAsync(new DeleteSpotDatafeedSubscriptionRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future deleteSubnetAsync(DeleteSubnetRequest request) {

        return deleteSubnetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteSubnetAsync(final DeleteSubnetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteSubnetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteSubnetResult call() throws Exception {
                DeleteSubnetResult result = null;

                try {
                    result = executeDeleteSubnet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteSubnetCidrReservationAsync(DeleteSubnetCidrReservationRequest request) {

        return deleteSubnetCidrReservationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteSubnetCidrReservationAsync(final DeleteSubnetCidrReservationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteSubnetCidrReservationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteSubnetCidrReservationResult call() throws Exception {
                DeleteSubnetCidrReservationResult result = null;

                try {
                    result = executeDeleteSubnetCidrReservation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTagsAsync(DeleteTagsRequest request) {

        return deleteTagsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTagsAsync(final DeleteTagsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTagsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTagsResult call() throws Exception {
                DeleteTagsResult result = null;

                try {
                    result = executeDeleteTags(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTrafficMirrorFilterAsync(DeleteTrafficMirrorFilterRequest request) {

        return deleteTrafficMirrorFilterAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTrafficMirrorFilterAsync(final DeleteTrafficMirrorFilterRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTrafficMirrorFilterRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTrafficMirrorFilterResult call() throws Exception {
                DeleteTrafficMirrorFilterResult result = null;

                try {
                    result = executeDeleteTrafficMirrorFilter(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTrafficMirrorFilterRuleAsync(DeleteTrafficMirrorFilterRuleRequest request) {

        return deleteTrafficMirrorFilterRuleAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTrafficMirrorFilterRuleAsync(
            final DeleteTrafficMirrorFilterRuleRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTrafficMirrorFilterRuleRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTrafficMirrorFilterRuleResult call() throws Exception {
                DeleteTrafficMirrorFilterRuleResult result = null;

                try {
                    result = executeDeleteTrafficMirrorFilterRule(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTrafficMirrorSessionAsync(DeleteTrafficMirrorSessionRequest request) {

        return deleteTrafficMirrorSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTrafficMirrorSessionAsync(final DeleteTrafficMirrorSessionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTrafficMirrorSessionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTrafficMirrorSessionResult call() throws Exception {
                DeleteTrafficMirrorSessionResult result = null;

                try {
                    result = executeDeleteTrafficMirrorSession(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTrafficMirrorTargetAsync(DeleteTrafficMirrorTargetRequest request) {

        return deleteTrafficMirrorTargetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTrafficMirrorTargetAsync(final DeleteTrafficMirrorTargetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTrafficMirrorTargetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTrafficMirrorTargetResult call() throws Exception {
                DeleteTrafficMirrorTargetResult result = null;

                try {
                    result = executeDeleteTrafficMirrorTarget(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayAsync(DeleteTransitGatewayRequest request) {

        return deleteTransitGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayAsync(final DeleteTransitGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTransitGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTransitGatewayResult call() throws Exception {
                DeleteTransitGatewayResult result = null;

                try {
                    result = executeDeleteTransitGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayConnectAsync(DeleteTransitGatewayConnectRequest request) {

        return deleteTransitGatewayConnectAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayConnectAsync(final DeleteTransitGatewayConnectRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTransitGatewayConnectRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTransitGatewayConnectResult call() throws Exception {
                DeleteTransitGatewayConnectResult result = null;

                try {
                    result = executeDeleteTransitGatewayConnect(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayConnectPeerAsync(
            DeleteTransitGatewayConnectPeerRequest request) {

        return deleteTransitGatewayConnectPeerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayConnectPeerAsync(
            final DeleteTransitGatewayConnectPeerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTransitGatewayConnectPeerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTransitGatewayConnectPeerResult call() throws Exception {
                DeleteTransitGatewayConnectPeerResult result = null;

                try {
                    result = executeDeleteTransitGatewayConnectPeer(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayMulticastDomainAsync(
            DeleteTransitGatewayMulticastDomainRequest request) {

        return deleteTransitGatewayMulticastDomainAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayMulticastDomainAsync(
            final DeleteTransitGatewayMulticastDomainRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTransitGatewayMulticastDomainRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTransitGatewayMulticastDomainResult call() throws Exception {
                DeleteTransitGatewayMulticastDomainResult result = null;

                try {
                    result = executeDeleteTransitGatewayMulticastDomain(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayPeeringAttachmentAsync(
            DeleteTransitGatewayPeeringAttachmentRequest request) {

        return deleteTransitGatewayPeeringAttachmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayPeeringAttachmentAsync(
            final DeleteTransitGatewayPeeringAttachmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTransitGatewayPeeringAttachmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTransitGatewayPeeringAttachmentResult call() throws Exception {
                DeleteTransitGatewayPeeringAttachmentResult result = null;

                try {
                    result = executeDeleteTransitGatewayPeeringAttachment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayPrefixListReferenceAsync(
            DeleteTransitGatewayPrefixListReferenceRequest request) {

        return deleteTransitGatewayPrefixListReferenceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayPrefixListReferenceAsync(
            final DeleteTransitGatewayPrefixListReferenceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTransitGatewayPrefixListReferenceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTransitGatewayPrefixListReferenceResult call() throws Exception {
                DeleteTransitGatewayPrefixListReferenceResult result = null;

                try {
                    result = executeDeleteTransitGatewayPrefixListReference(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayRouteAsync(DeleteTransitGatewayRouteRequest request) {

        return deleteTransitGatewayRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayRouteAsync(final DeleteTransitGatewayRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTransitGatewayRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTransitGatewayRouteResult call() throws Exception {
                DeleteTransitGatewayRouteResult result = null;

                try {
                    result = executeDeleteTransitGatewayRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayRouteTableAsync(DeleteTransitGatewayRouteTableRequest request) {

        return deleteTransitGatewayRouteTableAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayRouteTableAsync(
            final DeleteTransitGatewayRouteTableRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTransitGatewayRouteTableRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTransitGatewayRouteTableResult call() throws Exception {
                DeleteTransitGatewayRouteTableResult result = null;

                try {
                    result = executeDeleteTransitGatewayRouteTable(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayVpcAttachmentAsync(
            DeleteTransitGatewayVpcAttachmentRequest request) {

        return deleteTransitGatewayVpcAttachmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTransitGatewayVpcAttachmentAsync(
            final DeleteTransitGatewayVpcAttachmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTransitGatewayVpcAttachmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTransitGatewayVpcAttachmentResult call() throws Exception {
                DeleteTransitGatewayVpcAttachmentResult result = null;

                try {
                    result = executeDeleteTransitGatewayVpcAttachment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteVolumeAsync(DeleteVolumeRequest request) {

        return deleteVolumeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteVolumeAsync(final DeleteVolumeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteVolumeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteVolumeResult call() throws Exception {
                DeleteVolumeResult result = null;

                try {
                    result = executeDeleteVolume(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteVpcAsync(DeleteVpcRequest request) {

        return deleteVpcAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteVpcAsync(final DeleteVpcRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteVpcRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteVpcResult call() throws Exception {
                DeleteVpcResult result = null;

                try {
                    result = executeDeleteVpc(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteVpcEndpointConnectionNotificationsAsync(
            DeleteVpcEndpointConnectionNotificationsRequest request) {

        return deleteVpcEndpointConnectionNotificationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteVpcEndpointConnectionNotificationsAsync(
            final DeleteVpcEndpointConnectionNotificationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteVpcEndpointConnectionNotificationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteVpcEndpointConnectionNotificationsResult call() throws Exception {
                DeleteVpcEndpointConnectionNotificationsResult result = null;

                try {
                    result = executeDeleteVpcEndpointConnectionNotifications(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteVpcEndpointServiceConfigurationsAsync(
            DeleteVpcEndpointServiceConfigurationsRequest request) {

        return deleteVpcEndpointServiceConfigurationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteVpcEndpointServiceConfigurationsAsync(
            final DeleteVpcEndpointServiceConfigurationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteVpcEndpointServiceConfigurationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteVpcEndpointServiceConfigurationsResult call() throws Exception {
                DeleteVpcEndpointServiceConfigurationsResult result = null;

                try {
                    result = executeDeleteVpcEndpointServiceConfigurations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteVpcEndpointsAsync(DeleteVpcEndpointsRequest request) {

        return deleteVpcEndpointsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteVpcEndpointsAsync(final DeleteVpcEndpointsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteVpcEndpointsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteVpcEndpointsResult call() throws Exception {
                DeleteVpcEndpointsResult result = null;

                try {
                    result = executeDeleteVpcEndpoints(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteVpcPeeringConnectionAsync(DeleteVpcPeeringConnectionRequest request) {

        return deleteVpcPeeringConnectionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteVpcPeeringConnectionAsync(final DeleteVpcPeeringConnectionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteVpcPeeringConnectionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteVpcPeeringConnectionResult call() throws Exception {
                DeleteVpcPeeringConnectionResult result = null;

                try {
                    result = executeDeleteVpcPeeringConnection(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteVpnConnectionAsync(DeleteVpnConnectionRequest request) {

        return deleteVpnConnectionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteVpnConnectionAsync(final DeleteVpnConnectionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteVpnConnectionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteVpnConnectionResult call() throws Exception {
                DeleteVpnConnectionResult result = null;

                try {
                    result = executeDeleteVpnConnection(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteVpnConnectionRouteAsync(DeleteVpnConnectionRouteRequest request) {

        return deleteVpnConnectionRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteVpnConnectionRouteAsync(final DeleteVpnConnectionRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteVpnConnectionRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteVpnConnectionRouteResult call() throws Exception {
                DeleteVpnConnectionRouteResult result = null;

                try {
                    result = executeDeleteVpnConnectionRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deleteVpnGatewayAsync(DeleteVpnGatewayRequest request) {

        return deleteVpnGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteVpnGatewayAsync(final DeleteVpnGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteVpnGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteVpnGatewayResult call() throws Exception {
                DeleteVpnGatewayResult result = null;

                try {
                    result = executeDeleteVpnGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deprovisionByoipCidrAsync(DeprovisionByoipCidrRequest request) {

        return deprovisionByoipCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deprovisionByoipCidrAsync(final DeprovisionByoipCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeprovisionByoipCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeprovisionByoipCidrResult call() throws Exception {
                DeprovisionByoipCidrResult result = null;

                try {
                    result = executeDeprovisionByoipCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deprovisionIpamPoolCidrAsync(DeprovisionIpamPoolCidrRequest request) {

        return deprovisionIpamPoolCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deprovisionIpamPoolCidrAsync(final DeprovisionIpamPoolCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeprovisionIpamPoolCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeprovisionIpamPoolCidrResult call() throws Exception {
                DeprovisionIpamPoolCidrResult result = null;

                try {
                    result = executeDeprovisionIpamPoolCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deprovisionPublicIpv4PoolCidrAsync(DeprovisionPublicIpv4PoolCidrRequest request) {

        return deprovisionPublicIpv4PoolCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deprovisionPublicIpv4PoolCidrAsync(
            final DeprovisionPublicIpv4PoolCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeprovisionPublicIpv4PoolCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeprovisionPublicIpv4PoolCidrResult call() throws Exception {
                DeprovisionPublicIpv4PoolCidrResult result = null;

                try {
                    result = executeDeprovisionPublicIpv4PoolCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deregisterImageAsync(DeregisterImageRequest request) {

        return deregisterImageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deregisterImageAsync(final DeregisterImageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeregisterImageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeregisterImageResult call() throws Exception {
                DeregisterImageResult result = null;

                try {
                    result = executeDeregisterImage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deregisterInstanceEventNotificationAttributesAsync(
            DeregisterInstanceEventNotificationAttributesRequest request) {

        return deregisterInstanceEventNotificationAttributesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deregisterInstanceEventNotificationAttributesAsync(
            final DeregisterInstanceEventNotificationAttributesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeregisterInstanceEventNotificationAttributesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeregisterInstanceEventNotificationAttributesResult call() throws Exception {
                DeregisterInstanceEventNotificationAttributesResult result = null;

                try {
                    result = executeDeregisterInstanceEventNotificationAttributes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deregisterTransitGatewayMulticastGroupMembersAsync(
            DeregisterTransitGatewayMulticastGroupMembersRequest request) {

        return deregisterTransitGatewayMulticastGroupMembersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deregisterTransitGatewayMulticastGroupMembersAsync(
            final DeregisterTransitGatewayMulticastGroupMembersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeregisterTransitGatewayMulticastGroupMembersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeregisterTransitGatewayMulticastGroupMembersResult call() throws Exception {
                DeregisterTransitGatewayMulticastGroupMembersResult result = null;

                try {
                    result = executeDeregisterTransitGatewayMulticastGroupMembers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future deregisterTransitGatewayMulticastGroupSourcesAsync(
            DeregisterTransitGatewayMulticastGroupSourcesRequest request) {

        return deregisterTransitGatewayMulticastGroupSourcesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deregisterTransitGatewayMulticastGroupSourcesAsync(
            final DeregisterTransitGatewayMulticastGroupSourcesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeregisterTransitGatewayMulticastGroupSourcesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeregisterTransitGatewayMulticastGroupSourcesResult call() throws Exception {
                DeregisterTransitGatewayMulticastGroupSourcesResult result = null;

                try {
                    result = executeDeregisterTransitGatewayMulticastGroupSources(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeAccountAttributesAsync(DescribeAccountAttributesRequest request) {

        return describeAccountAttributesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeAccountAttributesAsync(final DescribeAccountAttributesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeAccountAttributesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeAccountAttributesResult call() throws Exception {
                DescribeAccountAttributesResult result = null;

                try {
                    result = executeDescribeAccountAttributes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeAccountAttributes operation.
     *
     * @see #describeAccountAttributesAsync(DescribeAccountAttributesRequest)
     */
    @Override
    public java.util.concurrent.Future describeAccountAttributesAsync() {

        return describeAccountAttributesAsync(new DescribeAccountAttributesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeAccountAttributes operation with an AsyncHandler.
     *
     * @see #describeAccountAttributesAsync(DescribeAccountAttributesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeAccountAttributesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeAccountAttributesAsync(new DescribeAccountAttributesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeAddressesAsync(DescribeAddressesRequest request) {

        return describeAddressesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeAddressesAsync(final DescribeAddressesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeAddressesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeAddressesResult call() throws Exception {
                DescribeAddressesResult result = null;

                try {
                    result = executeDescribeAddresses(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeAddresses operation.
     *
     * @see #describeAddressesAsync(DescribeAddressesRequest)
     */
    @Override
    public java.util.concurrent.Future describeAddressesAsync() {

        return describeAddressesAsync(new DescribeAddressesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeAddresses operation with an AsyncHandler.
     *
     * @see #describeAddressesAsync(DescribeAddressesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeAddressesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeAddressesAsync(new DescribeAddressesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeAddressesAttributeAsync(DescribeAddressesAttributeRequest request) {

        return describeAddressesAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeAddressesAttributeAsync(final DescribeAddressesAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeAddressesAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeAddressesAttributeResult call() throws Exception {
                DescribeAddressesAttributeResult result = null;

                try {
                    result = executeDescribeAddressesAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeAggregateIdFormatAsync(DescribeAggregateIdFormatRequest request) {

        return describeAggregateIdFormatAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeAggregateIdFormatAsync(final DescribeAggregateIdFormatRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeAggregateIdFormatRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeAggregateIdFormatResult call() throws Exception {
                DescribeAggregateIdFormatResult result = null;

                try {
                    result = executeDescribeAggregateIdFormat(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeAvailabilityZonesAsync(DescribeAvailabilityZonesRequest request) {

        return describeAvailabilityZonesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeAvailabilityZonesAsync(final DescribeAvailabilityZonesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeAvailabilityZonesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeAvailabilityZonesResult call() throws Exception {
                DescribeAvailabilityZonesResult result = null;

                try {
                    result = executeDescribeAvailabilityZones(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeAvailabilityZones operation.
     *
     * @see #describeAvailabilityZonesAsync(DescribeAvailabilityZonesRequest)
     */
    @Override
    public java.util.concurrent.Future describeAvailabilityZonesAsync() {

        return describeAvailabilityZonesAsync(new DescribeAvailabilityZonesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeAvailabilityZones operation with an AsyncHandler.
     *
     * @see #describeAvailabilityZonesAsync(DescribeAvailabilityZonesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeAvailabilityZonesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeAvailabilityZonesAsync(new DescribeAvailabilityZonesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeBundleTasksAsync(DescribeBundleTasksRequest request) {

        return describeBundleTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeBundleTasksAsync(final DescribeBundleTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeBundleTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeBundleTasksResult call() throws Exception {
                DescribeBundleTasksResult result = null;

                try {
                    result = executeDescribeBundleTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeBundleTasks operation.
     *
     * @see #describeBundleTasksAsync(DescribeBundleTasksRequest)
     */
    @Override
    public java.util.concurrent.Future describeBundleTasksAsync() {

        return describeBundleTasksAsync(new DescribeBundleTasksRequest());
    }

    /**
     * Simplified method form for invoking the DescribeBundleTasks operation with an AsyncHandler.
     *
     * @see #describeBundleTasksAsync(DescribeBundleTasksRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeBundleTasksAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeBundleTasksAsync(new DescribeBundleTasksRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeByoipCidrsAsync(DescribeByoipCidrsRequest request) {

        return describeByoipCidrsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeByoipCidrsAsync(final DescribeByoipCidrsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeByoipCidrsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeByoipCidrsResult call() throws Exception {
                DescribeByoipCidrsResult result = null;

                try {
                    result = executeDescribeByoipCidrs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeCapacityReservationFleetsAsync(
            DescribeCapacityReservationFleetsRequest request) {

        return describeCapacityReservationFleetsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeCapacityReservationFleetsAsync(
            final DescribeCapacityReservationFleetsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeCapacityReservationFleetsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeCapacityReservationFleetsResult call() throws Exception {
                DescribeCapacityReservationFleetsResult result = null;

                try {
                    result = executeDescribeCapacityReservationFleets(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeCapacityReservationsAsync(DescribeCapacityReservationsRequest request) {

        return describeCapacityReservationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeCapacityReservationsAsync(final DescribeCapacityReservationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeCapacityReservationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeCapacityReservationsResult call() throws Exception {
                DescribeCapacityReservationsResult result = null;

                try {
                    result = executeDescribeCapacityReservations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeCarrierGatewaysAsync(DescribeCarrierGatewaysRequest request) {

        return describeCarrierGatewaysAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeCarrierGatewaysAsync(final DescribeCarrierGatewaysRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeCarrierGatewaysRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeCarrierGatewaysResult call() throws Exception {
                DescribeCarrierGatewaysResult result = null;

                try {
                    result = executeDescribeCarrierGateways(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeClassicLinkInstancesAsync(DescribeClassicLinkInstancesRequest request) {

        return describeClassicLinkInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeClassicLinkInstancesAsync(final DescribeClassicLinkInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeClassicLinkInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeClassicLinkInstancesResult call() throws Exception {
                DescribeClassicLinkInstancesResult result = null;

                try {
                    result = executeDescribeClassicLinkInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeClassicLinkInstances operation.
     *
     * @see #describeClassicLinkInstancesAsync(DescribeClassicLinkInstancesRequest)
     */
    @Override
    public java.util.concurrent.Future describeClassicLinkInstancesAsync() {

        return describeClassicLinkInstancesAsync(new DescribeClassicLinkInstancesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeClassicLinkInstances operation with an AsyncHandler.
     *
     * @see #describeClassicLinkInstancesAsync(DescribeClassicLinkInstancesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeClassicLinkInstancesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeClassicLinkInstancesAsync(new DescribeClassicLinkInstancesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeClientVpnAuthorizationRulesAsync(
            DescribeClientVpnAuthorizationRulesRequest request) {

        return describeClientVpnAuthorizationRulesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeClientVpnAuthorizationRulesAsync(
            final DescribeClientVpnAuthorizationRulesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeClientVpnAuthorizationRulesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeClientVpnAuthorizationRulesResult call() throws Exception {
                DescribeClientVpnAuthorizationRulesResult result = null;

                try {
                    result = executeDescribeClientVpnAuthorizationRules(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeClientVpnConnectionsAsync(DescribeClientVpnConnectionsRequest request) {

        return describeClientVpnConnectionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeClientVpnConnectionsAsync(final DescribeClientVpnConnectionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeClientVpnConnectionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeClientVpnConnectionsResult call() throws Exception {
                DescribeClientVpnConnectionsResult result = null;

                try {
                    result = executeDescribeClientVpnConnections(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeClientVpnEndpointsAsync(DescribeClientVpnEndpointsRequest request) {

        return describeClientVpnEndpointsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeClientVpnEndpointsAsync(final DescribeClientVpnEndpointsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeClientVpnEndpointsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeClientVpnEndpointsResult call() throws Exception {
                DescribeClientVpnEndpointsResult result = null;

                try {
                    result = executeDescribeClientVpnEndpoints(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeClientVpnRoutesAsync(DescribeClientVpnRoutesRequest request) {

        return describeClientVpnRoutesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeClientVpnRoutesAsync(final DescribeClientVpnRoutesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeClientVpnRoutesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeClientVpnRoutesResult call() throws Exception {
                DescribeClientVpnRoutesResult result = null;

                try {
                    result = executeDescribeClientVpnRoutes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeClientVpnTargetNetworksAsync(
            DescribeClientVpnTargetNetworksRequest request) {

        return describeClientVpnTargetNetworksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeClientVpnTargetNetworksAsync(
            final DescribeClientVpnTargetNetworksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeClientVpnTargetNetworksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeClientVpnTargetNetworksResult call() throws Exception {
                DescribeClientVpnTargetNetworksResult result = null;

                try {
                    result = executeDescribeClientVpnTargetNetworks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeCoipPoolsAsync(DescribeCoipPoolsRequest request) {

        return describeCoipPoolsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeCoipPoolsAsync(final DescribeCoipPoolsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeCoipPoolsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeCoipPoolsResult call() throws Exception {
                DescribeCoipPoolsResult result = null;

                try {
                    result = executeDescribeCoipPools(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeConversionTasksAsync(DescribeConversionTasksRequest request) {

        return describeConversionTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeConversionTasksAsync(final DescribeConversionTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeConversionTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeConversionTasksResult call() throws Exception {
                DescribeConversionTasksResult result = null;

                try {
                    result = executeDescribeConversionTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeConversionTasks operation.
     *
     * @see #describeConversionTasksAsync(DescribeConversionTasksRequest)
     */
    @Override
    public java.util.concurrent.Future describeConversionTasksAsync() {

        return describeConversionTasksAsync(new DescribeConversionTasksRequest());
    }

    /**
     * Simplified method form for invoking the DescribeConversionTasks operation with an AsyncHandler.
     *
     * @see #describeConversionTasksAsync(DescribeConversionTasksRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeConversionTasksAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeConversionTasksAsync(new DescribeConversionTasksRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeCustomerGatewaysAsync(DescribeCustomerGatewaysRequest request) {

        return describeCustomerGatewaysAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeCustomerGatewaysAsync(final DescribeCustomerGatewaysRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeCustomerGatewaysRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeCustomerGatewaysResult call() throws Exception {
                DescribeCustomerGatewaysResult result = null;

                try {
                    result = executeDescribeCustomerGateways(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeCustomerGateways operation.
     *
     * @see #describeCustomerGatewaysAsync(DescribeCustomerGatewaysRequest)
     */
    @Override
    public java.util.concurrent.Future describeCustomerGatewaysAsync() {

        return describeCustomerGatewaysAsync(new DescribeCustomerGatewaysRequest());
    }

    /**
     * Simplified method form for invoking the DescribeCustomerGateways operation with an AsyncHandler.
     *
     * @see #describeCustomerGatewaysAsync(DescribeCustomerGatewaysRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeCustomerGatewaysAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeCustomerGatewaysAsync(new DescribeCustomerGatewaysRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeDhcpOptionsAsync(DescribeDhcpOptionsRequest request) {

        return describeDhcpOptionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeDhcpOptionsAsync(final DescribeDhcpOptionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeDhcpOptionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeDhcpOptionsResult call() throws Exception {
                DescribeDhcpOptionsResult result = null;

                try {
                    result = executeDescribeDhcpOptions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeDhcpOptions operation.
     *
     * @see #describeDhcpOptionsAsync(DescribeDhcpOptionsRequest)
     */
    @Override
    public java.util.concurrent.Future describeDhcpOptionsAsync() {

        return describeDhcpOptionsAsync(new DescribeDhcpOptionsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeDhcpOptions operation with an AsyncHandler.
     *
     * @see #describeDhcpOptionsAsync(DescribeDhcpOptionsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeDhcpOptionsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeDhcpOptionsAsync(new DescribeDhcpOptionsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeEgressOnlyInternetGatewaysAsync(
            DescribeEgressOnlyInternetGatewaysRequest request) {

        return describeEgressOnlyInternetGatewaysAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeEgressOnlyInternetGatewaysAsync(
            final DescribeEgressOnlyInternetGatewaysRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeEgressOnlyInternetGatewaysRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeEgressOnlyInternetGatewaysResult call() throws Exception {
                DescribeEgressOnlyInternetGatewaysResult result = null;

                try {
                    result = executeDescribeEgressOnlyInternetGateways(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeElasticGpusAsync(DescribeElasticGpusRequest request) {

        return describeElasticGpusAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeElasticGpusAsync(final DescribeElasticGpusRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeElasticGpusRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeElasticGpusResult call() throws Exception {
                DescribeElasticGpusResult result = null;

                try {
                    result = executeDescribeElasticGpus(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeExportImageTasksAsync(DescribeExportImageTasksRequest request) {

        return describeExportImageTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeExportImageTasksAsync(final DescribeExportImageTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeExportImageTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeExportImageTasksResult call() throws Exception {
                DescribeExportImageTasksResult result = null;

                try {
                    result = executeDescribeExportImageTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeExportTasksAsync(DescribeExportTasksRequest request) {

        return describeExportTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeExportTasksAsync(final DescribeExportTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeExportTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeExportTasksResult call() throws Exception {
                DescribeExportTasksResult result = null;

                try {
                    result = executeDescribeExportTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeExportTasks operation.
     *
     * @see #describeExportTasksAsync(DescribeExportTasksRequest)
     */
    @Override
    public java.util.concurrent.Future describeExportTasksAsync() {

        return describeExportTasksAsync(new DescribeExportTasksRequest());
    }

    /**
     * Simplified method form for invoking the DescribeExportTasks operation with an AsyncHandler.
     *
     * @see #describeExportTasksAsync(DescribeExportTasksRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeExportTasksAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeExportTasksAsync(new DescribeExportTasksRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeFastLaunchImagesAsync(DescribeFastLaunchImagesRequest request) {

        return describeFastLaunchImagesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeFastLaunchImagesAsync(final DescribeFastLaunchImagesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeFastLaunchImagesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeFastLaunchImagesResult call() throws Exception {
                DescribeFastLaunchImagesResult result = null;

                try {
                    result = executeDescribeFastLaunchImages(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeFastSnapshotRestoresAsync(DescribeFastSnapshotRestoresRequest request) {

        return describeFastSnapshotRestoresAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeFastSnapshotRestoresAsync(final DescribeFastSnapshotRestoresRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeFastSnapshotRestoresRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeFastSnapshotRestoresResult call() throws Exception {
                DescribeFastSnapshotRestoresResult result = null;

                try {
                    result = executeDescribeFastSnapshotRestores(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeFleetHistoryAsync(DescribeFleetHistoryRequest request) {

        return describeFleetHistoryAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeFleetHistoryAsync(final DescribeFleetHistoryRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeFleetHistoryRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeFleetHistoryResult call() throws Exception {
                DescribeFleetHistoryResult result = null;

                try {
                    result = executeDescribeFleetHistory(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeFleetInstancesAsync(DescribeFleetInstancesRequest request) {

        return describeFleetInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeFleetInstancesAsync(final DescribeFleetInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeFleetInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeFleetInstancesResult call() throws Exception {
                DescribeFleetInstancesResult result = null;

                try {
                    result = executeDescribeFleetInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeFleetsAsync(DescribeFleetsRequest request) {

        return describeFleetsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeFleetsAsync(final DescribeFleetsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeFleetsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeFleetsResult call() throws Exception {
                DescribeFleetsResult result = null;

                try {
                    result = executeDescribeFleets(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeFlowLogsAsync(DescribeFlowLogsRequest request) {

        return describeFlowLogsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeFlowLogsAsync(final DescribeFlowLogsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeFlowLogsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeFlowLogsResult call() throws Exception {
                DescribeFlowLogsResult result = null;

                try {
                    result = executeDescribeFlowLogs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeFlowLogs operation.
     *
     * @see #describeFlowLogsAsync(DescribeFlowLogsRequest)
     */
    @Override
    public java.util.concurrent.Future describeFlowLogsAsync() {

        return describeFlowLogsAsync(new DescribeFlowLogsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeFlowLogs operation with an AsyncHandler.
     *
     * @see #describeFlowLogsAsync(DescribeFlowLogsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeFlowLogsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeFlowLogsAsync(new DescribeFlowLogsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeFpgaImageAttributeAsync(DescribeFpgaImageAttributeRequest request) {

        return describeFpgaImageAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeFpgaImageAttributeAsync(final DescribeFpgaImageAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeFpgaImageAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeFpgaImageAttributeResult call() throws Exception {
                DescribeFpgaImageAttributeResult result = null;

                try {
                    result = executeDescribeFpgaImageAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeFpgaImagesAsync(DescribeFpgaImagesRequest request) {

        return describeFpgaImagesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeFpgaImagesAsync(final DescribeFpgaImagesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeFpgaImagesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeFpgaImagesResult call() throws Exception {
                DescribeFpgaImagesResult result = null;

                try {
                    result = executeDescribeFpgaImages(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeHostReservationOfferingsAsync(
            DescribeHostReservationOfferingsRequest request) {

        return describeHostReservationOfferingsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeHostReservationOfferingsAsync(
            final DescribeHostReservationOfferingsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeHostReservationOfferingsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeHostReservationOfferingsResult call() throws Exception {
                DescribeHostReservationOfferingsResult result = null;

                try {
                    result = executeDescribeHostReservationOfferings(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeHostReservationsAsync(DescribeHostReservationsRequest request) {

        return describeHostReservationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeHostReservationsAsync(final DescribeHostReservationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeHostReservationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeHostReservationsResult call() throws Exception {
                DescribeHostReservationsResult result = null;

                try {
                    result = executeDescribeHostReservations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeHostsAsync(DescribeHostsRequest request) {

        return describeHostsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeHostsAsync(final DescribeHostsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeHostsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeHostsResult call() throws Exception {
                DescribeHostsResult result = null;

                try {
                    result = executeDescribeHosts(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeHosts operation.
     *
     * @see #describeHostsAsync(DescribeHostsRequest)
     */
    @Override
    public java.util.concurrent.Future describeHostsAsync() {

        return describeHostsAsync(new DescribeHostsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeHosts operation with an AsyncHandler.
     *
     * @see #describeHostsAsync(DescribeHostsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeHostsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeHostsAsync(new DescribeHostsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeIamInstanceProfileAssociationsAsync(
            DescribeIamInstanceProfileAssociationsRequest request) {

        return describeIamInstanceProfileAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeIamInstanceProfileAssociationsAsync(
            final DescribeIamInstanceProfileAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeIamInstanceProfileAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeIamInstanceProfileAssociationsResult call() throws Exception {
                DescribeIamInstanceProfileAssociationsResult result = null;

                try {
                    result = executeDescribeIamInstanceProfileAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeIdFormatAsync(DescribeIdFormatRequest request) {

        return describeIdFormatAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeIdFormatAsync(final DescribeIdFormatRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeIdFormatRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeIdFormatResult call() throws Exception {
                DescribeIdFormatResult result = null;

                try {
                    result = executeDescribeIdFormat(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeIdFormat operation.
     *
     * @see #describeIdFormatAsync(DescribeIdFormatRequest)
     */
    @Override
    public java.util.concurrent.Future describeIdFormatAsync() {

        return describeIdFormatAsync(new DescribeIdFormatRequest());
    }

    /**
     * Simplified method form for invoking the DescribeIdFormat operation with an AsyncHandler.
     *
     * @see #describeIdFormatAsync(DescribeIdFormatRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeIdFormatAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeIdFormatAsync(new DescribeIdFormatRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeIdentityIdFormatAsync(DescribeIdentityIdFormatRequest request) {

        return describeIdentityIdFormatAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeIdentityIdFormatAsync(final DescribeIdentityIdFormatRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeIdentityIdFormatRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeIdentityIdFormatResult call() throws Exception {
                DescribeIdentityIdFormatResult result = null;

                try {
                    result = executeDescribeIdentityIdFormat(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeImageAttributeAsync(DescribeImageAttributeRequest request) {

        return describeImageAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeImageAttributeAsync(final DescribeImageAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeImageAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeImageAttributeResult call() throws Exception {
                DescribeImageAttributeResult result = null;

                try {
                    result = executeDescribeImageAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeImagesAsync(DescribeImagesRequest request) {

        return describeImagesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeImagesAsync(final DescribeImagesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeImagesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeImagesResult call() throws Exception {
                DescribeImagesResult result = null;

                try {
                    result = executeDescribeImages(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeImages operation.
     *
     * @see #describeImagesAsync(DescribeImagesRequest)
     */
    @Override
    public java.util.concurrent.Future describeImagesAsync() {

        return describeImagesAsync(new DescribeImagesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeImages operation with an AsyncHandler.
     *
     * @see #describeImagesAsync(DescribeImagesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeImagesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeImagesAsync(new DescribeImagesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeImportImageTasksAsync(DescribeImportImageTasksRequest request) {

        return describeImportImageTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeImportImageTasksAsync(final DescribeImportImageTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeImportImageTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeImportImageTasksResult call() throws Exception {
                DescribeImportImageTasksResult result = null;

                try {
                    result = executeDescribeImportImageTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeImportImageTasks operation.
     *
     * @see #describeImportImageTasksAsync(DescribeImportImageTasksRequest)
     */
    @Override
    public java.util.concurrent.Future describeImportImageTasksAsync() {

        return describeImportImageTasksAsync(new DescribeImportImageTasksRequest());
    }

    /**
     * Simplified method form for invoking the DescribeImportImageTasks operation with an AsyncHandler.
     *
     * @see #describeImportImageTasksAsync(DescribeImportImageTasksRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeImportImageTasksAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeImportImageTasksAsync(new DescribeImportImageTasksRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeImportSnapshotTasksAsync(DescribeImportSnapshotTasksRequest request) {

        return describeImportSnapshotTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeImportSnapshotTasksAsync(final DescribeImportSnapshotTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeImportSnapshotTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeImportSnapshotTasksResult call() throws Exception {
                DescribeImportSnapshotTasksResult result = null;

                try {
                    result = executeDescribeImportSnapshotTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeImportSnapshotTasks operation.
     *
     * @see #describeImportSnapshotTasksAsync(DescribeImportSnapshotTasksRequest)
     */
    @Override
    public java.util.concurrent.Future describeImportSnapshotTasksAsync() {

        return describeImportSnapshotTasksAsync(new DescribeImportSnapshotTasksRequest());
    }

    /**
     * Simplified method form for invoking the DescribeImportSnapshotTasks operation with an AsyncHandler.
     *
     * @see #describeImportSnapshotTasksAsync(DescribeImportSnapshotTasksRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeImportSnapshotTasksAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeImportSnapshotTasksAsync(new DescribeImportSnapshotTasksRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeInstanceAttributeAsync(DescribeInstanceAttributeRequest request) {

        return describeInstanceAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeInstanceAttributeAsync(final DescribeInstanceAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeInstanceAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeInstanceAttributeResult call() throws Exception {
                DescribeInstanceAttributeResult result = null;

                try {
                    result = executeDescribeInstanceAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeInstanceCreditSpecificationsAsync(
            DescribeInstanceCreditSpecificationsRequest request) {

        return describeInstanceCreditSpecificationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeInstanceCreditSpecificationsAsync(
            final DescribeInstanceCreditSpecificationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeInstanceCreditSpecificationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeInstanceCreditSpecificationsResult call() throws Exception {
                DescribeInstanceCreditSpecificationsResult result = null;

                try {
                    result = executeDescribeInstanceCreditSpecifications(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeInstanceEventNotificationAttributesAsync(
            DescribeInstanceEventNotificationAttributesRequest request) {

        return describeInstanceEventNotificationAttributesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeInstanceEventNotificationAttributesAsync(
            final DescribeInstanceEventNotificationAttributesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeInstanceEventNotificationAttributesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeInstanceEventNotificationAttributesResult call() throws Exception {
                DescribeInstanceEventNotificationAttributesResult result = null;

                try {
                    result = executeDescribeInstanceEventNotificationAttributes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeInstanceEventWindowsAsync(DescribeInstanceEventWindowsRequest request) {

        return describeInstanceEventWindowsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeInstanceEventWindowsAsync(final DescribeInstanceEventWindowsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeInstanceEventWindowsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeInstanceEventWindowsResult call() throws Exception {
                DescribeInstanceEventWindowsResult result = null;

                try {
                    result = executeDescribeInstanceEventWindows(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeInstanceStatusAsync(DescribeInstanceStatusRequest request) {

        return describeInstanceStatusAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeInstanceStatusAsync(final DescribeInstanceStatusRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeInstanceStatusRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeInstanceStatusResult call() throws Exception {
                DescribeInstanceStatusResult result = null;

                try {
                    result = executeDescribeInstanceStatus(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeInstanceStatus operation.
     *
     * @see #describeInstanceStatusAsync(DescribeInstanceStatusRequest)
     */
    @Override
    public java.util.concurrent.Future describeInstanceStatusAsync() {

        return describeInstanceStatusAsync(new DescribeInstanceStatusRequest());
    }

    /**
     * Simplified method form for invoking the DescribeInstanceStatus operation with an AsyncHandler.
     *
     * @see #describeInstanceStatusAsync(DescribeInstanceStatusRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeInstanceStatusAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeInstanceStatusAsync(new DescribeInstanceStatusRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeInstanceTypeOfferingsAsync(DescribeInstanceTypeOfferingsRequest request) {

        return describeInstanceTypeOfferingsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeInstanceTypeOfferingsAsync(
            final DescribeInstanceTypeOfferingsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeInstanceTypeOfferingsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeInstanceTypeOfferingsResult call() throws Exception {
                DescribeInstanceTypeOfferingsResult result = null;

                try {
                    result = executeDescribeInstanceTypeOfferings(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeInstanceTypesAsync(DescribeInstanceTypesRequest request) {

        return describeInstanceTypesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeInstanceTypesAsync(final DescribeInstanceTypesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeInstanceTypesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeInstanceTypesResult call() throws Exception {
                DescribeInstanceTypesResult result = null;

                try {
                    result = executeDescribeInstanceTypes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeInstancesAsync(DescribeInstancesRequest request) {

        return describeInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeInstancesAsync(final DescribeInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeInstancesResult call() throws Exception {
                DescribeInstancesResult result = null;

                try {
                    result = executeDescribeInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeInstances operation.
     *
     * @see #describeInstancesAsync(DescribeInstancesRequest)
     */
    @Override
    public java.util.concurrent.Future describeInstancesAsync() {

        return describeInstancesAsync(new DescribeInstancesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeInstances operation with an AsyncHandler.
     *
     * @see #describeInstancesAsync(DescribeInstancesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeInstancesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeInstancesAsync(new DescribeInstancesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeInternetGatewaysAsync(DescribeInternetGatewaysRequest request) {

        return describeInternetGatewaysAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeInternetGatewaysAsync(final DescribeInternetGatewaysRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeInternetGatewaysRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeInternetGatewaysResult call() throws Exception {
                DescribeInternetGatewaysResult result = null;

                try {
                    result = executeDescribeInternetGateways(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeInternetGateways operation.
     *
     * @see #describeInternetGatewaysAsync(DescribeInternetGatewaysRequest)
     */
    @Override
    public java.util.concurrent.Future describeInternetGatewaysAsync() {

        return describeInternetGatewaysAsync(new DescribeInternetGatewaysRequest());
    }

    /**
     * Simplified method form for invoking the DescribeInternetGateways operation with an AsyncHandler.
     *
     * @see #describeInternetGatewaysAsync(DescribeInternetGatewaysRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeInternetGatewaysAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeInternetGatewaysAsync(new DescribeInternetGatewaysRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeIpamPoolsAsync(DescribeIpamPoolsRequest request) {

        return describeIpamPoolsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeIpamPoolsAsync(final DescribeIpamPoolsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeIpamPoolsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeIpamPoolsResult call() throws Exception {
                DescribeIpamPoolsResult result = null;

                try {
                    result = executeDescribeIpamPools(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeIpamScopesAsync(DescribeIpamScopesRequest request) {

        return describeIpamScopesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeIpamScopesAsync(final DescribeIpamScopesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeIpamScopesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeIpamScopesResult call() throws Exception {
                DescribeIpamScopesResult result = null;

                try {
                    result = executeDescribeIpamScopes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeIpamsAsync(DescribeIpamsRequest request) {

        return describeIpamsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeIpamsAsync(final DescribeIpamsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeIpamsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeIpamsResult call() throws Exception {
                DescribeIpamsResult result = null;

                try {
                    result = executeDescribeIpams(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeIpv6PoolsAsync(DescribeIpv6PoolsRequest request) {

        return describeIpv6PoolsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeIpv6PoolsAsync(final DescribeIpv6PoolsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeIpv6PoolsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeIpv6PoolsResult call() throws Exception {
                DescribeIpv6PoolsResult result = null;

                try {
                    result = executeDescribeIpv6Pools(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeKeyPairsAsync(DescribeKeyPairsRequest request) {

        return describeKeyPairsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeKeyPairsAsync(final DescribeKeyPairsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeKeyPairsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeKeyPairsResult call() throws Exception {
                DescribeKeyPairsResult result = null;

                try {
                    result = executeDescribeKeyPairs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeKeyPairs operation.
     *
     * @see #describeKeyPairsAsync(DescribeKeyPairsRequest)
     */
    @Override
    public java.util.concurrent.Future describeKeyPairsAsync() {

        return describeKeyPairsAsync(new DescribeKeyPairsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeKeyPairs operation with an AsyncHandler.
     *
     * @see #describeKeyPairsAsync(DescribeKeyPairsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeKeyPairsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeKeyPairsAsync(new DescribeKeyPairsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeLaunchTemplateVersionsAsync(DescribeLaunchTemplateVersionsRequest request) {

        return describeLaunchTemplateVersionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeLaunchTemplateVersionsAsync(
            final DescribeLaunchTemplateVersionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeLaunchTemplateVersionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeLaunchTemplateVersionsResult call() throws Exception {
                DescribeLaunchTemplateVersionsResult result = null;

                try {
                    result = executeDescribeLaunchTemplateVersions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeLaunchTemplatesAsync(DescribeLaunchTemplatesRequest request) {

        return describeLaunchTemplatesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeLaunchTemplatesAsync(final DescribeLaunchTemplatesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeLaunchTemplatesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeLaunchTemplatesResult call() throws Exception {
                DescribeLaunchTemplatesResult result = null;

                try {
                    result = executeDescribeLaunchTemplates(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsAsync(
            DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest request) {

        return describeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsAsync(
            final DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResult call() throws Exception {
                DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsResult result = null;

                try {
                    result = executeDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayRouteTableVpcAssociationsAsync(
            DescribeLocalGatewayRouteTableVpcAssociationsRequest request) {

        return describeLocalGatewayRouteTableVpcAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayRouteTableVpcAssociationsAsync(
            final DescribeLocalGatewayRouteTableVpcAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeLocalGatewayRouteTableVpcAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeLocalGatewayRouteTableVpcAssociationsResult call() throws Exception {
                DescribeLocalGatewayRouteTableVpcAssociationsResult result = null;

                try {
                    result = executeDescribeLocalGatewayRouteTableVpcAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayRouteTablesAsync(
            DescribeLocalGatewayRouteTablesRequest request) {

        return describeLocalGatewayRouteTablesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayRouteTablesAsync(
            final DescribeLocalGatewayRouteTablesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeLocalGatewayRouteTablesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeLocalGatewayRouteTablesResult call() throws Exception {
                DescribeLocalGatewayRouteTablesResult result = null;

                try {
                    result = executeDescribeLocalGatewayRouteTables(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayVirtualInterfaceGroupsAsync(
            DescribeLocalGatewayVirtualInterfaceGroupsRequest request) {

        return describeLocalGatewayVirtualInterfaceGroupsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayVirtualInterfaceGroupsAsync(
            final DescribeLocalGatewayVirtualInterfaceGroupsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeLocalGatewayVirtualInterfaceGroupsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeLocalGatewayVirtualInterfaceGroupsResult call() throws Exception {
                DescribeLocalGatewayVirtualInterfaceGroupsResult result = null;

                try {
                    result = executeDescribeLocalGatewayVirtualInterfaceGroups(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayVirtualInterfacesAsync(
            DescribeLocalGatewayVirtualInterfacesRequest request) {

        return describeLocalGatewayVirtualInterfacesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewayVirtualInterfacesAsync(
            final DescribeLocalGatewayVirtualInterfacesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeLocalGatewayVirtualInterfacesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeLocalGatewayVirtualInterfacesResult call() throws Exception {
                DescribeLocalGatewayVirtualInterfacesResult result = null;

                try {
                    result = executeDescribeLocalGatewayVirtualInterfaces(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewaysAsync(DescribeLocalGatewaysRequest request) {

        return describeLocalGatewaysAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeLocalGatewaysAsync(final DescribeLocalGatewaysRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeLocalGatewaysRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeLocalGatewaysResult call() throws Exception {
                DescribeLocalGatewaysResult result = null;

                try {
                    result = executeDescribeLocalGateways(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeManagedPrefixListsAsync(DescribeManagedPrefixListsRequest request) {

        return describeManagedPrefixListsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeManagedPrefixListsAsync(final DescribeManagedPrefixListsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeManagedPrefixListsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeManagedPrefixListsResult call() throws Exception {
                DescribeManagedPrefixListsResult result = null;

                try {
                    result = executeDescribeManagedPrefixLists(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeMovingAddressesAsync(DescribeMovingAddressesRequest request) {

        return describeMovingAddressesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeMovingAddressesAsync(final DescribeMovingAddressesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeMovingAddressesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeMovingAddressesResult call() throws Exception {
                DescribeMovingAddressesResult result = null;

                try {
                    result = executeDescribeMovingAddresses(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeMovingAddresses operation.
     *
     * @see #describeMovingAddressesAsync(DescribeMovingAddressesRequest)
     */
    @Override
    public java.util.concurrent.Future describeMovingAddressesAsync() {

        return describeMovingAddressesAsync(new DescribeMovingAddressesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeMovingAddresses operation with an AsyncHandler.
     *
     * @see #describeMovingAddressesAsync(DescribeMovingAddressesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeMovingAddressesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeMovingAddressesAsync(new DescribeMovingAddressesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeNatGatewaysAsync(DescribeNatGatewaysRequest request) {

        return describeNatGatewaysAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeNatGatewaysAsync(final DescribeNatGatewaysRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeNatGatewaysRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeNatGatewaysResult call() throws Exception {
                DescribeNatGatewaysResult result = null;

                try {
                    result = executeDescribeNatGateways(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeNetworkAclsAsync(DescribeNetworkAclsRequest request) {

        return describeNetworkAclsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeNetworkAclsAsync(final DescribeNetworkAclsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeNetworkAclsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeNetworkAclsResult call() throws Exception {
                DescribeNetworkAclsResult result = null;

                try {
                    result = executeDescribeNetworkAcls(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeNetworkAcls operation.
     *
     * @see #describeNetworkAclsAsync(DescribeNetworkAclsRequest)
     */
    @Override
    public java.util.concurrent.Future describeNetworkAclsAsync() {

        return describeNetworkAclsAsync(new DescribeNetworkAclsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeNetworkAcls operation with an AsyncHandler.
     *
     * @see #describeNetworkAclsAsync(DescribeNetworkAclsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeNetworkAclsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeNetworkAclsAsync(new DescribeNetworkAclsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeNetworkInsightsAccessScopeAnalysesAsync(
            DescribeNetworkInsightsAccessScopeAnalysesRequest request) {

        return describeNetworkInsightsAccessScopeAnalysesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeNetworkInsightsAccessScopeAnalysesAsync(
            final DescribeNetworkInsightsAccessScopeAnalysesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeNetworkInsightsAccessScopeAnalysesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeNetworkInsightsAccessScopeAnalysesResult call() throws Exception {
                DescribeNetworkInsightsAccessScopeAnalysesResult result = null;

                try {
                    result = executeDescribeNetworkInsightsAccessScopeAnalyses(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeNetworkInsightsAccessScopesAsync(
            DescribeNetworkInsightsAccessScopesRequest request) {

        return describeNetworkInsightsAccessScopesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeNetworkInsightsAccessScopesAsync(
            final DescribeNetworkInsightsAccessScopesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeNetworkInsightsAccessScopesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeNetworkInsightsAccessScopesResult call() throws Exception {
                DescribeNetworkInsightsAccessScopesResult result = null;

                try {
                    result = executeDescribeNetworkInsightsAccessScopes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeNetworkInsightsAnalysesAsync(
            DescribeNetworkInsightsAnalysesRequest request) {

        return describeNetworkInsightsAnalysesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeNetworkInsightsAnalysesAsync(
            final DescribeNetworkInsightsAnalysesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeNetworkInsightsAnalysesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeNetworkInsightsAnalysesResult call() throws Exception {
                DescribeNetworkInsightsAnalysesResult result = null;

                try {
                    result = executeDescribeNetworkInsightsAnalyses(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeNetworkInsightsPathsAsync(DescribeNetworkInsightsPathsRequest request) {

        return describeNetworkInsightsPathsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeNetworkInsightsPathsAsync(final DescribeNetworkInsightsPathsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeNetworkInsightsPathsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeNetworkInsightsPathsResult call() throws Exception {
                DescribeNetworkInsightsPathsResult result = null;

                try {
                    result = executeDescribeNetworkInsightsPaths(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeNetworkInterfaceAttributeAsync(
            DescribeNetworkInterfaceAttributeRequest request) {

        return describeNetworkInterfaceAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeNetworkInterfaceAttributeAsync(
            final DescribeNetworkInterfaceAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeNetworkInterfaceAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeNetworkInterfaceAttributeResult call() throws Exception {
                DescribeNetworkInterfaceAttributeResult result = null;

                try {
                    result = executeDescribeNetworkInterfaceAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeNetworkInterfacePermissionsAsync(
            DescribeNetworkInterfacePermissionsRequest request) {

        return describeNetworkInterfacePermissionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeNetworkInterfacePermissionsAsync(
            final DescribeNetworkInterfacePermissionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeNetworkInterfacePermissionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeNetworkInterfacePermissionsResult call() throws Exception {
                DescribeNetworkInterfacePermissionsResult result = null;

                try {
                    result = executeDescribeNetworkInterfacePermissions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeNetworkInterfacesAsync(DescribeNetworkInterfacesRequest request) {

        return describeNetworkInterfacesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeNetworkInterfacesAsync(final DescribeNetworkInterfacesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeNetworkInterfacesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeNetworkInterfacesResult call() throws Exception {
                DescribeNetworkInterfacesResult result = null;

                try {
                    result = executeDescribeNetworkInterfaces(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeNetworkInterfaces operation.
     *
     * @see #describeNetworkInterfacesAsync(DescribeNetworkInterfacesRequest)
     */
    @Override
    public java.util.concurrent.Future describeNetworkInterfacesAsync() {

        return describeNetworkInterfacesAsync(new DescribeNetworkInterfacesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeNetworkInterfaces operation with an AsyncHandler.
     *
     * @see #describeNetworkInterfacesAsync(DescribeNetworkInterfacesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeNetworkInterfacesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeNetworkInterfacesAsync(new DescribeNetworkInterfacesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describePlacementGroupsAsync(DescribePlacementGroupsRequest request) {

        return describePlacementGroupsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describePlacementGroupsAsync(final DescribePlacementGroupsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribePlacementGroupsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribePlacementGroupsResult call() throws Exception {
                DescribePlacementGroupsResult result = null;

                try {
                    result = executeDescribePlacementGroups(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribePlacementGroups operation.
     *
     * @see #describePlacementGroupsAsync(DescribePlacementGroupsRequest)
     */
    @Override
    public java.util.concurrent.Future describePlacementGroupsAsync() {

        return describePlacementGroupsAsync(new DescribePlacementGroupsRequest());
    }

    /**
     * Simplified method form for invoking the DescribePlacementGroups operation with an AsyncHandler.
     *
     * @see #describePlacementGroupsAsync(DescribePlacementGroupsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describePlacementGroupsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describePlacementGroupsAsync(new DescribePlacementGroupsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describePrefixListsAsync(DescribePrefixListsRequest request) {

        return describePrefixListsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describePrefixListsAsync(final DescribePrefixListsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribePrefixListsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribePrefixListsResult call() throws Exception {
                DescribePrefixListsResult result = null;

                try {
                    result = executeDescribePrefixLists(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribePrefixLists operation.
     *
     * @see #describePrefixListsAsync(DescribePrefixListsRequest)
     */
    @Override
    public java.util.concurrent.Future describePrefixListsAsync() {

        return describePrefixListsAsync(new DescribePrefixListsRequest());
    }

    /**
     * Simplified method form for invoking the DescribePrefixLists operation with an AsyncHandler.
     *
     * @see #describePrefixListsAsync(DescribePrefixListsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describePrefixListsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describePrefixListsAsync(new DescribePrefixListsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describePrincipalIdFormatAsync(DescribePrincipalIdFormatRequest request) {

        return describePrincipalIdFormatAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describePrincipalIdFormatAsync(final DescribePrincipalIdFormatRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribePrincipalIdFormatRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribePrincipalIdFormatResult call() throws Exception {
                DescribePrincipalIdFormatResult result = null;

                try {
                    result = executeDescribePrincipalIdFormat(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describePublicIpv4PoolsAsync(DescribePublicIpv4PoolsRequest request) {

        return describePublicIpv4PoolsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describePublicIpv4PoolsAsync(final DescribePublicIpv4PoolsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribePublicIpv4PoolsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribePublicIpv4PoolsResult call() throws Exception {
                DescribePublicIpv4PoolsResult result = null;

                try {
                    result = executeDescribePublicIpv4Pools(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeRegionsAsync(DescribeRegionsRequest request) {

        return describeRegionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeRegionsAsync(final DescribeRegionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeRegionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeRegionsResult call() throws Exception {
                DescribeRegionsResult result = null;

                try {
                    result = executeDescribeRegions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeRegions operation.
     *
     * @see #describeRegionsAsync(DescribeRegionsRequest)
     */
    @Override
    public java.util.concurrent.Future describeRegionsAsync() {

        return describeRegionsAsync(new DescribeRegionsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeRegions operation with an AsyncHandler.
     *
     * @see #describeRegionsAsync(DescribeRegionsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeRegionsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeRegionsAsync(new DescribeRegionsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeReplaceRootVolumeTasksAsync(DescribeReplaceRootVolumeTasksRequest request) {

        return describeReplaceRootVolumeTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeReplaceRootVolumeTasksAsync(
            final DescribeReplaceRootVolumeTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeReplaceRootVolumeTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeReplaceRootVolumeTasksResult call() throws Exception {
                DescribeReplaceRootVolumeTasksResult result = null;

                try {
                    result = executeDescribeReplaceRootVolumeTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeReservedInstancesAsync(DescribeReservedInstancesRequest request) {

        return describeReservedInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeReservedInstancesAsync(final DescribeReservedInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeReservedInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeReservedInstancesResult call() throws Exception {
                DescribeReservedInstancesResult result = null;

                try {
                    result = executeDescribeReservedInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeReservedInstances operation.
     *
     * @see #describeReservedInstancesAsync(DescribeReservedInstancesRequest)
     */
    @Override
    public java.util.concurrent.Future describeReservedInstancesAsync() {

        return describeReservedInstancesAsync(new DescribeReservedInstancesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeReservedInstances operation with an AsyncHandler.
     *
     * @see #describeReservedInstancesAsync(DescribeReservedInstancesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeReservedInstancesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeReservedInstancesAsync(new DescribeReservedInstancesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeReservedInstancesListingsAsync(
            DescribeReservedInstancesListingsRequest request) {

        return describeReservedInstancesListingsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeReservedInstancesListingsAsync(
            final DescribeReservedInstancesListingsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeReservedInstancesListingsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeReservedInstancesListingsResult call() throws Exception {
                DescribeReservedInstancesListingsResult result = null;

                try {
                    result = executeDescribeReservedInstancesListings(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeReservedInstancesListings operation.
     *
     * @see #describeReservedInstancesListingsAsync(DescribeReservedInstancesListingsRequest)
     */
    @Override
    public java.util.concurrent.Future describeReservedInstancesListingsAsync() {

        return describeReservedInstancesListingsAsync(new DescribeReservedInstancesListingsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeReservedInstancesListings operation with an AsyncHandler.
     *
     * @see #describeReservedInstancesListingsAsync(DescribeReservedInstancesListingsRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeReservedInstancesListingsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeReservedInstancesListingsAsync(new DescribeReservedInstancesListingsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeReservedInstancesModificationsAsync(
            DescribeReservedInstancesModificationsRequest request) {

        return describeReservedInstancesModificationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeReservedInstancesModificationsAsync(
            final DescribeReservedInstancesModificationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeReservedInstancesModificationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeReservedInstancesModificationsResult call() throws Exception {
                DescribeReservedInstancesModificationsResult result = null;

                try {
                    result = executeDescribeReservedInstancesModifications(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeReservedInstancesModifications operation.
     *
     * @see #describeReservedInstancesModificationsAsync(DescribeReservedInstancesModificationsRequest)
     */
    @Override
    public java.util.concurrent.Future describeReservedInstancesModificationsAsync() {

        return describeReservedInstancesModificationsAsync(new DescribeReservedInstancesModificationsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeReservedInstancesModifications operation with an AsyncHandler.
     *
     * @see #describeReservedInstancesModificationsAsync(DescribeReservedInstancesModificationsRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeReservedInstancesModificationsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeReservedInstancesModificationsAsync(new DescribeReservedInstancesModificationsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeReservedInstancesOfferingsAsync(
            DescribeReservedInstancesOfferingsRequest request) {

        return describeReservedInstancesOfferingsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeReservedInstancesOfferingsAsync(
            final DescribeReservedInstancesOfferingsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeReservedInstancesOfferingsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeReservedInstancesOfferingsResult call() throws Exception {
                DescribeReservedInstancesOfferingsResult result = null;

                try {
                    result = executeDescribeReservedInstancesOfferings(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeReservedInstancesOfferings operation.
     *
     * @see #describeReservedInstancesOfferingsAsync(DescribeReservedInstancesOfferingsRequest)
     */
    @Override
    public java.util.concurrent.Future describeReservedInstancesOfferingsAsync() {

        return describeReservedInstancesOfferingsAsync(new DescribeReservedInstancesOfferingsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeReservedInstancesOfferings operation with an AsyncHandler.
     *
     * @see #describeReservedInstancesOfferingsAsync(DescribeReservedInstancesOfferingsRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeReservedInstancesOfferingsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeReservedInstancesOfferingsAsync(new DescribeReservedInstancesOfferingsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeRouteTablesAsync(DescribeRouteTablesRequest request) {

        return describeRouteTablesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeRouteTablesAsync(final DescribeRouteTablesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeRouteTablesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeRouteTablesResult call() throws Exception {
                DescribeRouteTablesResult result = null;

                try {
                    result = executeDescribeRouteTables(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeRouteTables operation.
     *
     * @see #describeRouteTablesAsync(DescribeRouteTablesRequest)
     */
    @Override
    public java.util.concurrent.Future describeRouteTablesAsync() {

        return describeRouteTablesAsync(new DescribeRouteTablesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeRouteTables operation with an AsyncHandler.
     *
     * @see #describeRouteTablesAsync(DescribeRouteTablesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeRouteTablesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeRouteTablesAsync(new DescribeRouteTablesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeScheduledInstanceAvailabilityAsync(
            DescribeScheduledInstanceAvailabilityRequest request) {

        return describeScheduledInstanceAvailabilityAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeScheduledInstanceAvailabilityAsync(
            final DescribeScheduledInstanceAvailabilityRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeScheduledInstanceAvailabilityRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeScheduledInstanceAvailabilityResult call() throws Exception {
                DescribeScheduledInstanceAvailabilityResult result = null;

                try {
                    result = executeDescribeScheduledInstanceAvailability(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeScheduledInstancesAsync(DescribeScheduledInstancesRequest request) {

        return describeScheduledInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeScheduledInstancesAsync(final DescribeScheduledInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeScheduledInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeScheduledInstancesResult call() throws Exception {
                DescribeScheduledInstancesResult result = null;

                try {
                    result = executeDescribeScheduledInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeSecurityGroupReferencesAsync(
            DescribeSecurityGroupReferencesRequest request) {

        return describeSecurityGroupReferencesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSecurityGroupReferencesAsync(
            final DescribeSecurityGroupReferencesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSecurityGroupReferencesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSecurityGroupReferencesResult call() throws Exception {
                DescribeSecurityGroupReferencesResult result = null;

                try {
                    result = executeDescribeSecurityGroupReferences(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeSecurityGroupRulesAsync(DescribeSecurityGroupRulesRequest request) {

        return describeSecurityGroupRulesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSecurityGroupRulesAsync(final DescribeSecurityGroupRulesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSecurityGroupRulesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSecurityGroupRulesResult call() throws Exception {
                DescribeSecurityGroupRulesResult result = null;

                try {
                    result = executeDescribeSecurityGroupRules(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeSecurityGroupsAsync(DescribeSecurityGroupsRequest request) {

        return describeSecurityGroupsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSecurityGroupsAsync(final DescribeSecurityGroupsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSecurityGroupsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSecurityGroupsResult call() throws Exception {
                DescribeSecurityGroupsResult result = null;

                try {
                    result = executeDescribeSecurityGroups(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeSecurityGroups operation.
     *
     * @see #describeSecurityGroupsAsync(DescribeSecurityGroupsRequest)
     */
    @Override
    public java.util.concurrent.Future describeSecurityGroupsAsync() {

        return describeSecurityGroupsAsync(new DescribeSecurityGroupsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeSecurityGroups operation with an AsyncHandler.
     *
     * @see #describeSecurityGroupsAsync(DescribeSecurityGroupsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeSecurityGroupsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeSecurityGroupsAsync(new DescribeSecurityGroupsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeSnapshotAttributeAsync(DescribeSnapshotAttributeRequest request) {

        return describeSnapshotAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSnapshotAttributeAsync(final DescribeSnapshotAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSnapshotAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSnapshotAttributeResult call() throws Exception {
                DescribeSnapshotAttributeResult result = null;

                try {
                    result = executeDescribeSnapshotAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeSnapshotTierStatusAsync(DescribeSnapshotTierStatusRequest request) {

        return describeSnapshotTierStatusAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSnapshotTierStatusAsync(final DescribeSnapshotTierStatusRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSnapshotTierStatusRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSnapshotTierStatusResult call() throws Exception {
                DescribeSnapshotTierStatusResult result = null;

                try {
                    result = executeDescribeSnapshotTierStatus(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeSnapshotsAsync(DescribeSnapshotsRequest request) {

        return describeSnapshotsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSnapshotsAsync(final DescribeSnapshotsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSnapshotsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSnapshotsResult call() throws Exception {
                DescribeSnapshotsResult result = null;

                try {
                    result = executeDescribeSnapshots(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeSnapshots operation.
     *
     * @see #describeSnapshotsAsync(DescribeSnapshotsRequest)
     */
    @Override
    public java.util.concurrent.Future describeSnapshotsAsync() {

        return describeSnapshotsAsync(new DescribeSnapshotsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeSnapshots operation with an AsyncHandler.
     *
     * @see #describeSnapshotsAsync(DescribeSnapshotsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeSnapshotsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeSnapshotsAsync(new DescribeSnapshotsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeSpotDatafeedSubscriptionAsync(
            DescribeSpotDatafeedSubscriptionRequest request) {

        return describeSpotDatafeedSubscriptionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSpotDatafeedSubscriptionAsync(
            final DescribeSpotDatafeedSubscriptionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSpotDatafeedSubscriptionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSpotDatafeedSubscriptionResult call() throws Exception {
                DescribeSpotDatafeedSubscriptionResult result = null;

                try {
                    result = executeDescribeSpotDatafeedSubscription(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeSpotDatafeedSubscription operation.
     *
     * @see #describeSpotDatafeedSubscriptionAsync(DescribeSpotDatafeedSubscriptionRequest)
     */
    @Override
    public java.util.concurrent.Future describeSpotDatafeedSubscriptionAsync() {

        return describeSpotDatafeedSubscriptionAsync(new DescribeSpotDatafeedSubscriptionRequest());
    }

    /**
     * Simplified method form for invoking the DescribeSpotDatafeedSubscription operation with an AsyncHandler.
     *
     * @see #describeSpotDatafeedSubscriptionAsync(DescribeSpotDatafeedSubscriptionRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeSpotDatafeedSubscriptionAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeSpotDatafeedSubscriptionAsync(new DescribeSpotDatafeedSubscriptionRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeSpotFleetInstancesAsync(DescribeSpotFleetInstancesRequest request) {

        return describeSpotFleetInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSpotFleetInstancesAsync(final DescribeSpotFleetInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSpotFleetInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSpotFleetInstancesResult call() throws Exception {
                DescribeSpotFleetInstancesResult result = null;

                try {
                    result = executeDescribeSpotFleetInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeSpotFleetRequestHistoryAsync(
            DescribeSpotFleetRequestHistoryRequest request) {

        return describeSpotFleetRequestHistoryAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSpotFleetRequestHistoryAsync(
            final DescribeSpotFleetRequestHistoryRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSpotFleetRequestHistoryRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSpotFleetRequestHistoryResult call() throws Exception {
                DescribeSpotFleetRequestHistoryResult result = null;

                try {
                    result = executeDescribeSpotFleetRequestHistory(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeSpotFleetRequestsAsync(DescribeSpotFleetRequestsRequest request) {

        return describeSpotFleetRequestsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSpotFleetRequestsAsync(final DescribeSpotFleetRequestsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSpotFleetRequestsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSpotFleetRequestsResult call() throws Exception {
                DescribeSpotFleetRequestsResult result = null;

                try {
                    result = executeDescribeSpotFleetRequests(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeSpotFleetRequests operation.
     *
     * @see #describeSpotFleetRequestsAsync(DescribeSpotFleetRequestsRequest)
     */
    @Override
    public java.util.concurrent.Future describeSpotFleetRequestsAsync() {

        return describeSpotFleetRequestsAsync(new DescribeSpotFleetRequestsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeSpotFleetRequests operation with an AsyncHandler.
     *
     * @see #describeSpotFleetRequestsAsync(DescribeSpotFleetRequestsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeSpotFleetRequestsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeSpotFleetRequestsAsync(new DescribeSpotFleetRequestsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeSpotInstanceRequestsAsync(DescribeSpotInstanceRequestsRequest request) {

        return describeSpotInstanceRequestsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSpotInstanceRequestsAsync(final DescribeSpotInstanceRequestsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSpotInstanceRequestsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSpotInstanceRequestsResult call() throws Exception {
                DescribeSpotInstanceRequestsResult result = null;

                try {
                    result = executeDescribeSpotInstanceRequests(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeSpotInstanceRequests operation.
     *
     * @see #describeSpotInstanceRequestsAsync(DescribeSpotInstanceRequestsRequest)
     */
    @Override
    public java.util.concurrent.Future describeSpotInstanceRequestsAsync() {

        return describeSpotInstanceRequestsAsync(new DescribeSpotInstanceRequestsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeSpotInstanceRequests operation with an AsyncHandler.
     *
     * @see #describeSpotInstanceRequestsAsync(DescribeSpotInstanceRequestsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeSpotInstanceRequestsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeSpotInstanceRequestsAsync(new DescribeSpotInstanceRequestsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeSpotPriceHistoryAsync(DescribeSpotPriceHistoryRequest request) {

        return describeSpotPriceHistoryAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSpotPriceHistoryAsync(final DescribeSpotPriceHistoryRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSpotPriceHistoryRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSpotPriceHistoryResult call() throws Exception {
                DescribeSpotPriceHistoryResult result = null;

                try {
                    result = executeDescribeSpotPriceHistory(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeSpotPriceHistory operation.
     *
     * @see #describeSpotPriceHistoryAsync(DescribeSpotPriceHistoryRequest)
     */
    @Override
    public java.util.concurrent.Future describeSpotPriceHistoryAsync() {

        return describeSpotPriceHistoryAsync(new DescribeSpotPriceHistoryRequest());
    }

    /**
     * Simplified method form for invoking the DescribeSpotPriceHistory operation with an AsyncHandler.
     *
     * @see #describeSpotPriceHistoryAsync(DescribeSpotPriceHistoryRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeSpotPriceHistoryAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeSpotPriceHistoryAsync(new DescribeSpotPriceHistoryRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeStaleSecurityGroupsAsync(DescribeStaleSecurityGroupsRequest request) {

        return describeStaleSecurityGroupsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeStaleSecurityGroupsAsync(final DescribeStaleSecurityGroupsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeStaleSecurityGroupsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeStaleSecurityGroupsResult call() throws Exception {
                DescribeStaleSecurityGroupsResult result = null;

                try {
                    result = executeDescribeStaleSecurityGroups(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeStoreImageTasksAsync(DescribeStoreImageTasksRequest request) {

        return describeStoreImageTasksAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeStoreImageTasksAsync(final DescribeStoreImageTasksRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeStoreImageTasksRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeStoreImageTasksResult call() throws Exception {
                DescribeStoreImageTasksResult result = null;

                try {
                    result = executeDescribeStoreImageTasks(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeSubnetsAsync(DescribeSubnetsRequest request) {

        return describeSubnetsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeSubnetsAsync(final DescribeSubnetsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeSubnetsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeSubnetsResult call() throws Exception {
                DescribeSubnetsResult result = null;

                try {
                    result = executeDescribeSubnets(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeSubnets operation.
     *
     * @see #describeSubnetsAsync(DescribeSubnetsRequest)
     */
    @Override
    public java.util.concurrent.Future describeSubnetsAsync() {

        return describeSubnetsAsync(new DescribeSubnetsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeSubnets operation with an AsyncHandler.
     *
     * @see #describeSubnetsAsync(DescribeSubnetsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeSubnetsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeSubnetsAsync(new DescribeSubnetsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeTagsAsync(DescribeTagsRequest request) {

        return describeTagsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTagsAsync(final DescribeTagsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTagsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTagsResult call() throws Exception {
                DescribeTagsResult result = null;

                try {
                    result = executeDescribeTags(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeTags operation.
     *
     * @see #describeTagsAsync(DescribeTagsRequest)
     */
    @Override
    public java.util.concurrent.Future describeTagsAsync() {

        return describeTagsAsync(new DescribeTagsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeTags operation with an AsyncHandler.
     *
     * @see #describeTagsAsync(DescribeTagsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeTagsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeTagsAsync(new DescribeTagsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeTrafficMirrorFiltersAsync(DescribeTrafficMirrorFiltersRequest request) {

        return describeTrafficMirrorFiltersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTrafficMirrorFiltersAsync(final DescribeTrafficMirrorFiltersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTrafficMirrorFiltersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTrafficMirrorFiltersResult call() throws Exception {
                DescribeTrafficMirrorFiltersResult result = null;

                try {
                    result = executeDescribeTrafficMirrorFilters(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTrafficMirrorSessionsAsync(DescribeTrafficMirrorSessionsRequest request) {

        return describeTrafficMirrorSessionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTrafficMirrorSessionsAsync(
            final DescribeTrafficMirrorSessionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTrafficMirrorSessionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTrafficMirrorSessionsResult call() throws Exception {
                DescribeTrafficMirrorSessionsResult result = null;

                try {
                    result = executeDescribeTrafficMirrorSessions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTrafficMirrorTargetsAsync(DescribeTrafficMirrorTargetsRequest request) {

        return describeTrafficMirrorTargetsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTrafficMirrorTargetsAsync(final DescribeTrafficMirrorTargetsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTrafficMirrorTargetsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTrafficMirrorTargetsResult call() throws Exception {
                DescribeTrafficMirrorTargetsResult result = null;

                try {
                    result = executeDescribeTrafficMirrorTargets(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayAttachmentsAsync(
            DescribeTransitGatewayAttachmentsRequest request) {

        return describeTransitGatewayAttachmentsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayAttachmentsAsync(
            final DescribeTransitGatewayAttachmentsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTransitGatewayAttachmentsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTransitGatewayAttachmentsResult call() throws Exception {
                DescribeTransitGatewayAttachmentsResult result = null;

                try {
                    result = executeDescribeTransitGatewayAttachments(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayConnectPeersAsync(
            DescribeTransitGatewayConnectPeersRequest request) {

        return describeTransitGatewayConnectPeersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayConnectPeersAsync(
            final DescribeTransitGatewayConnectPeersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTransitGatewayConnectPeersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTransitGatewayConnectPeersResult call() throws Exception {
                DescribeTransitGatewayConnectPeersResult result = null;

                try {
                    result = executeDescribeTransitGatewayConnectPeers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayConnectsAsync(DescribeTransitGatewayConnectsRequest request) {

        return describeTransitGatewayConnectsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayConnectsAsync(
            final DescribeTransitGatewayConnectsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTransitGatewayConnectsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTransitGatewayConnectsResult call() throws Exception {
                DescribeTransitGatewayConnectsResult result = null;

                try {
                    result = executeDescribeTransitGatewayConnects(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayMulticastDomainsAsync(
            DescribeTransitGatewayMulticastDomainsRequest request) {

        return describeTransitGatewayMulticastDomainsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayMulticastDomainsAsync(
            final DescribeTransitGatewayMulticastDomainsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTransitGatewayMulticastDomainsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTransitGatewayMulticastDomainsResult call() throws Exception {
                DescribeTransitGatewayMulticastDomainsResult result = null;

                try {
                    result = executeDescribeTransitGatewayMulticastDomains(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayPeeringAttachmentsAsync(
            DescribeTransitGatewayPeeringAttachmentsRequest request) {

        return describeTransitGatewayPeeringAttachmentsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayPeeringAttachmentsAsync(
            final DescribeTransitGatewayPeeringAttachmentsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTransitGatewayPeeringAttachmentsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTransitGatewayPeeringAttachmentsResult call() throws Exception {
                DescribeTransitGatewayPeeringAttachmentsResult result = null;

                try {
                    result = executeDescribeTransitGatewayPeeringAttachments(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayRouteTablesAsync(
            DescribeTransitGatewayRouteTablesRequest request) {

        return describeTransitGatewayRouteTablesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayRouteTablesAsync(
            final DescribeTransitGatewayRouteTablesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTransitGatewayRouteTablesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTransitGatewayRouteTablesResult call() throws Exception {
                DescribeTransitGatewayRouteTablesResult result = null;

                try {
                    result = executeDescribeTransitGatewayRouteTables(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayVpcAttachmentsAsync(
            DescribeTransitGatewayVpcAttachmentsRequest request) {

        return describeTransitGatewayVpcAttachmentsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewayVpcAttachmentsAsync(
            final DescribeTransitGatewayVpcAttachmentsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTransitGatewayVpcAttachmentsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTransitGatewayVpcAttachmentsResult call() throws Exception {
                DescribeTransitGatewayVpcAttachmentsResult result = null;

                try {
                    result = executeDescribeTransitGatewayVpcAttachments(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewaysAsync(DescribeTransitGatewaysRequest request) {

        return describeTransitGatewaysAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTransitGatewaysAsync(final DescribeTransitGatewaysRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTransitGatewaysRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTransitGatewaysResult call() throws Exception {
                DescribeTransitGatewaysResult result = null;

                try {
                    result = executeDescribeTransitGateways(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeTrunkInterfaceAssociationsAsync(
            DescribeTrunkInterfaceAssociationsRequest request) {

        return describeTrunkInterfaceAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeTrunkInterfaceAssociationsAsync(
            final DescribeTrunkInterfaceAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeTrunkInterfaceAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeTrunkInterfaceAssociationsResult call() throws Exception {
                DescribeTrunkInterfaceAssociationsResult result = null;

                try {
                    result = executeDescribeTrunkInterfaceAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeVolumeAttributeAsync(DescribeVolumeAttributeRequest request) {

        return describeVolumeAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVolumeAttributeAsync(final DescribeVolumeAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVolumeAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVolumeAttributeResult call() throws Exception {
                DescribeVolumeAttributeResult result = null;

                try {
                    result = executeDescribeVolumeAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeVolumeStatusAsync(DescribeVolumeStatusRequest request) {

        return describeVolumeStatusAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVolumeStatusAsync(final DescribeVolumeStatusRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVolumeStatusRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVolumeStatusResult call() throws Exception {
                DescribeVolumeStatusResult result = null;

                try {
                    result = executeDescribeVolumeStatus(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeVolumeStatus operation.
     *
     * @see #describeVolumeStatusAsync(DescribeVolumeStatusRequest)
     */
    @Override
    public java.util.concurrent.Future describeVolumeStatusAsync() {

        return describeVolumeStatusAsync(new DescribeVolumeStatusRequest());
    }

    /**
     * Simplified method form for invoking the DescribeVolumeStatus operation with an AsyncHandler.
     *
     * @see #describeVolumeStatusAsync(DescribeVolumeStatusRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeVolumeStatusAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeVolumeStatusAsync(new DescribeVolumeStatusRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeVolumesAsync(DescribeVolumesRequest request) {

        return describeVolumesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVolumesAsync(final DescribeVolumesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVolumesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVolumesResult call() throws Exception {
                DescribeVolumesResult result = null;

                try {
                    result = executeDescribeVolumes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeVolumes operation.
     *
     * @see #describeVolumesAsync(DescribeVolumesRequest)
     */
    @Override
    public java.util.concurrent.Future describeVolumesAsync() {

        return describeVolumesAsync(new DescribeVolumesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeVolumes operation with an AsyncHandler.
     *
     * @see #describeVolumesAsync(DescribeVolumesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeVolumesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeVolumesAsync(new DescribeVolumesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeVolumesModificationsAsync(DescribeVolumesModificationsRequest request) {

        return describeVolumesModificationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVolumesModificationsAsync(final DescribeVolumesModificationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVolumesModificationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVolumesModificationsResult call() throws Exception {
                DescribeVolumesModificationsResult result = null;

                try {
                    result = executeDescribeVolumesModifications(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeVpcAttributeAsync(DescribeVpcAttributeRequest request) {

        return describeVpcAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcAttributeAsync(final DescribeVpcAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcAttributeResult call() throws Exception {
                DescribeVpcAttributeResult result = null;

                try {
                    result = executeDescribeVpcAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeVpcClassicLinkAsync(DescribeVpcClassicLinkRequest request) {

        return describeVpcClassicLinkAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcClassicLinkAsync(final DescribeVpcClassicLinkRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcClassicLinkRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcClassicLinkResult call() throws Exception {
                DescribeVpcClassicLinkResult result = null;

                try {
                    result = executeDescribeVpcClassicLink(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeVpcClassicLink operation.
     *
     * @see #describeVpcClassicLinkAsync(DescribeVpcClassicLinkRequest)
     */
    @Override
    public java.util.concurrent.Future describeVpcClassicLinkAsync() {

        return describeVpcClassicLinkAsync(new DescribeVpcClassicLinkRequest());
    }

    /**
     * Simplified method form for invoking the DescribeVpcClassicLink operation with an AsyncHandler.
     *
     * @see #describeVpcClassicLinkAsync(DescribeVpcClassicLinkRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeVpcClassicLinkAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeVpcClassicLinkAsync(new DescribeVpcClassicLinkRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeVpcClassicLinkDnsSupportAsync(
            DescribeVpcClassicLinkDnsSupportRequest request) {

        return describeVpcClassicLinkDnsSupportAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcClassicLinkDnsSupportAsync(
            final DescribeVpcClassicLinkDnsSupportRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcClassicLinkDnsSupportRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcClassicLinkDnsSupportResult call() throws Exception {
                DescribeVpcClassicLinkDnsSupportResult result = null;

                try {
                    result = executeDescribeVpcClassicLinkDnsSupport(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointConnectionNotificationsAsync(
            DescribeVpcEndpointConnectionNotificationsRequest request) {

        return describeVpcEndpointConnectionNotificationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointConnectionNotificationsAsync(
            final DescribeVpcEndpointConnectionNotificationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcEndpointConnectionNotificationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcEndpointConnectionNotificationsResult call() throws Exception {
                DescribeVpcEndpointConnectionNotificationsResult result = null;

                try {
                    result = executeDescribeVpcEndpointConnectionNotifications(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointConnectionsAsync(DescribeVpcEndpointConnectionsRequest request) {

        return describeVpcEndpointConnectionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointConnectionsAsync(
            final DescribeVpcEndpointConnectionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcEndpointConnectionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcEndpointConnectionsResult call() throws Exception {
                DescribeVpcEndpointConnectionsResult result = null;

                try {
                    result = executeDescribeVpcEndpointConnections(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointServiceConfigurationsAsync(
            DescribeVpcEndpointServiceConfigurationsRequest request) {

        return describeVpcEndpointServiceConfigurationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointServiceConfigurationsAsync(
            final DescribeVpcEndpointServiceConfigurationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcEndpointServiceConfigurationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcEndpointServiceConfigurationsResult call() throws Exception {
                DescribeVpcEndpointServiceConfigurationsResult result = null;

                try {
                    result = executeDescribeVpcEndpointServiceConfigurations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointServicePermissionsAsync(
            DescribeVpcEndpointServicePermissionsRequest request) {

        return describeVpcEndpointServicePermissionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointServicePermissionsAsync(
            final DescribeVpcEndpointServicePermissionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcEndpointServicePermissionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcEndpointServicePermissionsResult call() throws Exception {
                DescribeVpcEndpointServicePermissionsResult result = null;

                try {
                    result = executeDescribeVpcEndpointServicePermissions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointServicesAsync(DescribeVpcEndpointServicesRequest request) {

        return describeVpcEndpointServicesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointServicesAsync(final DescribeVpcEndpointServicesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcEndpointServicesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcEndpointServicesResult call() throws Exception {
                DescribeVpcEndpointServicesResult result = null;

                try {
                    result = executeDescribeVpcEndpointServices(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeVpcEndpointServices operation.
     *
     * @see #describeVpcEndpointServicesAsync(DescribeVpcEndpointServicesRequest)
     */
    @Override
    public java.util.concurrent.Future describeVpcEndpointServicesAsync() {

        return describeVpcEndpointServicesAsync(new DescribeVpcEndpointServicesRequest());
    }

    /**
     * Simplified method form for invoking the DescribeVpcEndpointServices operation with an AsyncHandler.
     *
     * @see #describeVpcEndpointServicesAsync(DescribeVpcEndpointServicesRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeVpcEndpointServicesAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeVpcEndpointServicesAsync(new DescribeVpcEndpointServicesRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointsAsync(DescribeVpcEndpointsRequest request) {

        return describeVpcEndpointsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcEndpointsAsync(final DescribeVpcEndpointsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcEndpointsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcEndpointsResult call() throws Exception {
                DescribeVpcEndpointsResult result = null;

                try {
                    result = executeDescribeVpcEndpoints(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeVpcEndpoints operation.
     *
     * @see #describeVpcEndpointsAsync(DescribeVpcEndpointsRequest)
     */
    @Override
    public java.util.concurrent.Future describeVpcEndpointsAsync() {

        return describeVpcEndpointsAsync(new DescribeVpcEndpointsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeVpcEndpoints operation with an AsyncHandler.
     *
     * @see #describeVpcEndpointsAsync(DescribeVpcEndpointsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeVpcEndpointsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeVpcEndpointsAsync(new DescribeVpcEndpointsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeVpcPeeringConnectionsAsync(DescribeVpcPeeringConnectionsRequest request) {

        return describeVpcPeeringConnectionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcPeeringConnectionsAsync(
            final DescribeVpcPeeringConnectionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcPeeringConnectionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcPeeringConnectionsResult call() throws Exception {
                DescribeVpcPeeringConnectionsResult result = null;

                try {
                    result = executeDescribeVpcPeeringConnections(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeVpcPeeringConnections operation.
     *
     * @see #describeVpcPeeringConnectionsAsync(DescribeVpcPeeringConnectionsRequest)
     */
    @Override
    public java.util.concurrent.Future describeVpcPeeringConnectionsAsync() {

        return describeVpcPeeringConnectionsAsync(new DescribeVpcPeeringConnectionsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeVpcPeeringConnections operation with an AsyncHandler.
     *
     * @see #describeVpcPeeringConnectionsAsync(DescribeVpcPeeringConnectionsRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeVpcPeeringConnectionsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeVpcPeeringConnectionsAsync(new DescribeVpcPeeringConnectionsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeVpcsAsync(DescribeVpcsRequest request) {

        return describeVpcsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpcsAsync(final DescribeVpcsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpcsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpcsResult call() throws Exception {
                DescribeVpcsResult result = null;

                try {
                    result = executeDescribeVpcs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeVpcs operation.
     *
     * @see #describeVpcsAsync(DescribeVpcsRequest)
     */
    @Override
    public java.util.concurrent.Future describeVpcsAsync() {

        return describeVpcsAsync(new DescribeVpcsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeVpcs operation with an AsyncHandler.
     *
     * @see #describeVpcsAsync(DescribeVpcsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeVpcsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeVpcsAsync(new DescribeVpcsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeVpnConnectionsAsync(DescribeVpnConnectionsRequest request) {

        return describeVpnConnectionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpnConnectionsAsync(final DescribeVpnConnectionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpnConnectionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpnConnectionsResult call() throws Exception {
                DescribeVpnConnectionsResult result = null;

                try {
                    result = executeDescribeVpnConnections(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeVpnConnections operation.
     *
     * @see #describeVpnConnectionsAsync(DescribeVpnConnectionsRequest)
     */
    @Override
    public java.util.concurrent.Future describeVpnConnectionsAsync() {

        return describeVpnConnectionsAsync(new DescribeVpnConnectionsRequest());
    }

    /**
     * Simplified method form for invoking the DescribeVpnConnections operation with an AsyncHandler.
     *
     * @see #describeVpnConnectionsAsync(DescribeVpnConnectionsRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeVpnConnectionsAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeVpnConnectionsAsync(new DescribeVpnConnectionsRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future describeVpnGatewaysAsync(DescribeVpnGatewaysRequest request) {

        return describeVpnGatewaysAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future describeVpnGatewaysAsync(final DescribeVpnGatewaysRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DescribeVpnGatewaysRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DescribeVpnGatewaysResult call() throws Exception {
                DescribeVpnGatewaysResult result = null;

                try {
                    result = executeDescribeVpnGateways(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the DescribeVpnGateways operation.
     *
     * @see #describeVpnGatewaysAsync(DescribeVpnGatewaysRequest)
     */
    @Override
    public java.util.concurrent.Future describeVpnGatewaysAsync() {

        return describeVpnGatewaysAsync(new DescribeVpnGatewaysRequest());
    }

    /**
     * Simplified method form for invoking the DescribeVpnGateways operation with an AsyncHandler.
     *
     * @see #describeVpnGatewaysAsync(DescribeVpnGatewaysRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future describeVpnGatewaysAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return describeVpnGatewaysAsync(new DescribeVpnGatewaysRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future detachClassicLinkVpcAsync(DetachClassicLinkVpcRequest request) {

        return detachClassicLinkVpcAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future detachClassicLinkVpcAsync(final DetachClassicLinkVpcRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DetachClassicLinkVpcRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DetachClassicLinkVpcResult call() throws Exception {
                DetachClassicLinkVpcResult result = null;

                try {
                    result = executeDetachClassicLinkVpc(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future detachInternetGatewayAsync(DetachInternetGatewayRequest request) {

        return detachInternetGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future detachInternetGatewayAsync(final DetachInternetGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DetachInternetGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DetachInternetGatewayResult call() throws Exception {
                DetachInternetGatewayResult result = null;

                try {
                    result = executeDetachInternetGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future detachNetworkInterfaceAsync(DetachNetworkInterfaceRequest request) {

        return detachNetworkInterfaceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future detachNetworkInterfaceAsync(final DetachNetworkInterfaceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DetachNetworkInterfaceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DetachNetworkInterfaceResult call() throws Exception {
                DetachNetworkInterfaceResult result = null;

                try {
                    result = executeDetachNetworkInterface(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future detachVolumeAsync(DetachVolumeRequest request) {

        return detachVolumeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future detachVolumeAsync(final DetachVolumeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DetachVolumeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DetachVolumeResult call() throws Exception {
                DetachVolumeResult result = null;

                try {
                    result = executeDetachVolume(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future detachVpnGatewayAsync(DetachVpnGatewayRequest request) {

        return detachVpnGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future detachVpnGatewayAsync(final DetachVpnGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DetachVpnGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DetachVpnGatewayResult call() throws Exception {
                DetachVpnGatewayResult result = null;

                try {
                    result = executeDetachVpnGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableEbsEncryptionByDefaultAsync(DisableEbsEncryptionByDefaultRequest request) {

        return disableEbsEncryptionByDefaultAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableEbsEncryptionByDefaultAsync(
            final DisableEbsEncryptionByDefaultRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableEbsEncryptionByDefaultRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableEbsEncryptionByDefaultResult call() throws Exception {
                DisableEbsEncryptionByDefaultResult result = null;

                try {
                    result = executeDisableEbsEncryptionByDefault(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableFastLaunchAsync(DisableFastLaunchRequest request) {

        return disableFastLaunchAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableFastLaunchAsync(final DisableFastLaunchRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableFastLaunchRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableFastLaunchResult call() throws Exception {
                DisableFastLaunchResult result = null;

                try {
                    result = executeDisableFastLaunch(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableFastSnapshotRestoresAsync(DisableFastSnapshotRestoresRequest request) {

        return disableFastSnapshotRestoresAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableFastSnapshotRestoresAsync(final DisableFastSnapshotRestoresRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableFastSnapshotRestoresRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableFastSnapshotRestoresResult call() throws Exception {
                DisableFastSnapshotRestoresResult result = null;

                try {
                    result = executeDisableFastSnapshotRestores(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableImageDeprecationAsync(DisableImageDeprecationRequest request) {

        return disableImageDeprecationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableImageDeprecationAsync(final DisableImageDeprecationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableImageDeprecationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableImageDeprecationResult call() throws Exception {
                DisableImageDeprecationResult result = null;

                try {
                    result = executeDisableImageDeprecation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableIpamOrganizationAdminAccountAsync(
            DisableIpamOrganizationAdminAccountRequest request) {

        return disableIpamOrganizationAdminAccountAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableIpamOrganizationAdminAccountAsync(
            final DisableIpamOrganizationAdminAccountRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableIpamOrganizationAdminAccountRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableIpamOrganizationAdminAccountResult call() throws Exception {
                DisableIpamOrganizationAdminAccountResult result = null;

                try {
                    result = executeDisableIpamOrganizationAdminAccount(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableSerialConsoleAccessAsync(DisableSerialConsoleAccessRequest request) {

        return disableSerialConsoleAccessAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableSerialConsoleAccessAsync(final DisableSerialConsoleAccessRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableSerialConsoleAccessRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableSerialConsoleAccessResult call() throws Exception {
                DisableSerialConsoleAccessResult result = null;

                try {
                    result = executeDisableSerialConsoleAccess(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableTransitGatewayRouteTablePropagationAsync(
            DisableTransitGatewayRouteTablePropagationRequest request) {

        return disableTransitGatewayRouteTablePropagationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableTransitGatewayRouteTablePropagationAsync(
            final DisableTransitGatewayRouteTablePropagationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableTransitGatewayRouteTablePropagationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableTransitGatewayRouteTablePropagationResult call() throws Exception {
                DisableTransitGatewayRouteTablePropagationResult result = null;

                try {
                    result = executeDisableTransitGatewayRouteTablePropagation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableVgwRoutePropagationAsync(DisableVgwRoutePropagationRequest request) {

        return disableVgwRoutePropagationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableVgwRoutePropagationAsync(final DisableVgwRoutePropagationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableVgwRoutePropagationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableVgwRoutePropagationResult call() throws Exception {
                DisableVgwRoutePropagationResult result = null;

                try {
                    result = executeDisableVgwRoutePropagation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableVpcClassicLinkAsync(DisableVpcClassicLinkRequest request) {

        return disableVpcClassicLinkAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableVpcClassicLinkAsync(final DisableVpcClassicLinkRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableVpcClassicLinkRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableVpcClassicLinkResult call() throws Exception {
                DisableVpcClassicLinkResult result = null;

                try {
                    result = executeDisableVpcClassicLink(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disableVpcClassicLinkDnsSupportAsync(
            DisableVpcClassicLinkDnsSupportRequest request) {

        return disableVpcClassicLinkDnsSupportAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disableVpcClassicLinkDnsSupportAsync(
            final DisableVpcClassicLinkDnsSupportRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisableVpcClassicLinkDnsSupportRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisableVpcClassicLinkDnsSupportResult call() throws Exception {
                DisableVpcClassicLinkDnsSupportResult result = null;

                try {
                    result = executeDisableVpcClassicLinkDnsSupport(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateAddressAsync(DisassociateAddressRequest request) {

        return disassociateAddressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateAddressAsync(final DisassociateAddressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateAddressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateAddressResult call() throws Exception {
                DisassociateAddressResult result = null;

                try {
                    result = executeDisassociateAddress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateClientVpnTargetNetworkAsync(
            DisassociateClientVpnTargetNetworkRequest request) {

        return disassociateClientVpnTargetNetworkAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateClientVpnTargetNetworkAsync(
            final DisassociateClientVpnTargetNetworkRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateClientVpnTargetNetworkRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateClientVpnTargetNetworkResult call() throws Exception {
                DisassociateClientVpnTargetNetworkResult result = null;

                try {
                    result = executeDisassociateClientVpnTargetNetwork(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateEnclaveCertificateIamRoleAsync(
            DisassociateEnclaveCertificateIamRoleRequest request) {

        return disassociateEnclaveCertificateIamRoleAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateEnclaveCertificateIamRoleAsync(
            final DisassociateEnclaveCertificateIamRoleRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateEnclaveCertificateIamRoleRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateEnclaveCertificateIamRoleResult call() throws Exception {
                DisassociateEnclaveCertificateIamRoleResult result = null;

                try {
                    result = executeDisassociateEnclaveCertificateIamRole(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateIamInstanceProfileAsync(DisassociateIamInstanceProfileRequest request) {

        return disassociateIamInstanceProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateIamInstanceProfileAsync(
            final DisassociateIamInstanceProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateIamInstanceProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateIamInstanceProfileResult call() throws Exception {
                DisassociateIamInstanceProfileResult result = null;

                try {
                    result = executeDisassociateIamInstanceProfile(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateInstanceEventWindowAsync(
            DisassociateInstanceEventWindowRequest request) {

        return disassociateInstanceEventWindowAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateInstanceEventWindowAsync(
            final DisassociateInstanceEventWindowRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateInstanceEventWindowRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateInstanceEventWindowResult call() throws Exception {
                DisassociateInstanceEventWindowResult result = null;

                try {
                    result = executeDisassociateInstanceEventWindow(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateRouteTableAsync(DisassociateRouteTableRequest request) {

        return disassociateRouteTableAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateRouteTableAsync(final DisassociateRouteTableRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateRouteTableRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateRouteTableResult call() throws Exception {
                DisassociateRouteTableResult result = null;

                try {
                    result = executeDisassociateRouteTable(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateSubnetCidrBlockAsync(DisassociateSubnetCidrBlockRequest request) {

        return disassociateSubnetCidrBlockAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateSubnetCidrBlockAsync(final DisassociateSubnetCidrBlockRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateSubnetCidrBlockRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateSubnetCidrBlockResult call() throws Exception {
                DisassociateSubnetCidrBlockResult result = null;

                try {
                    result = executeDisassociateSubnetCidrBlock(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateTransitGatewayMulticastDomainAsync(
            DisassociateTransitGatewayMulticastDomainRequest request) {

        return disassociateTransitGatewayMulticastDomainAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateTransitGatewayMulticastDomainAsync(
            final DisassociateTransitGatewayMulticastDomainRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateTransitGatewayMulticastDomainRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateTransitGatewayMulticastDomainResult call() throws Exception {
                DisassociateTransitGatewayMulticastDomainResult result = null;

                try {
                    result = executeDisassociateTransitGatewayMulticastDomain(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateTransitGatewayRouteTableAsync(
            DisassociateTransitGatewayRouteTableRequest request) {

        return disassociateTransitGatewayRouteTableAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateTransitGatewayRouteTableAsync(
            final DisassociateTransitGatewayRouteTableRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateTransitGatewayRouteTableRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateTransitGatewayRouteTableResult call() throws Exception {
                DisassociateTransitGatewayRouteTableResult result = null;

                try {
                    result = executeDisassociateTransitGatewayRouteTable(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateTrunkInterfaceAsync(DisassociateTrunkInterfaceRequest request) {

        return disassociateTrunkInterfaceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateTrunkInterfaceAsync(final DisassociateTrunkInterfaceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateTrunkInterfaceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateTrunkInterfaceResult call() throws Exception {
                DisassociateTrunkInterfaceResult result = null;

                try {
                    result = executeDisassociateTrunkInterface(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future disassociateVpcCidrBlockAsync(DisassociateVpcCidrBlockRequest request) {

        return disassociateVpcCidrBlockAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateVpcCidrBlockAsync(final DisassociateVpcCidrBlockRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateVpcCidrBlockRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateVpcCidrBlockResult call() throws Exception {
                DisassociateVpcCidrBlockResult result = null;

                try {
                    result = executeDisassociateVpcCidrBlock(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableEbsEncryptionByDefaultAsync(EnableEbsEncryptionByDefaultRequest request) {

        return enableEbsEncryptionByDefaultAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableEbsEncryptionByDefaultAsync(final EnableEbsEncryptionByDefaultRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableEbsEncryptionByDefaultRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableEbsEncryptionByDefaultResult call() throws Exception {
                EnableEbsEncryptionByDefaultResult result = null;

                try {
                    result = executeEnableEbsEncryptionByDefault(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableFastLaunchAsync(EnableFastLaunchRequest request) {

        return enableFastLaunchAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableFastLaunchAsync(final EnableFastLaunchRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableFastLaunchRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableFastLaunchResult call() throws Exception {
                EnableFastLaunchResult result = null;

                try {
                    result = executeEnableFastLaunch(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableFastSnapshotRestoresAsync(EnableFastSnapshotRestoresRequest request) {

        return enableFastSnapshotRestoresAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableFastSnapshotRestoresAsync(final EnableFastSnapshotRestoresRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableFastSnapshotRestoresRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableFastSnapshotRestoresResult call() throws Exception {
                EnableFastSnapshotRestoresResult result = null;

                try {
                    result = executeEnableFastSnapshotRestores(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableImageDeprecationAsync(EnableImageDeprecationRequest request) {

        return enableImageDeprecationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableImageDeprecationAsync(final EnableImageDeprecationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableImageDeprecationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableImageDeprecationResult call() throws Exception {
                EnableImageDeprecationResult result = null;

                try {
                    result = executeEnableImageDeprecation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableIpamOrganizationAdminAccountAsync(
            EnableIpamOrganizationAdminAccountRequest request) {

        return enableIpamOrganizationAdminAccountAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableIpamOrganizationAdminAccountAsync(
            final EnableIpamOrganizationAdminAccountRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableIpamOrganizationAdminAccountRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableIpamOrganizationAdminAccountResult call() throws Exception {
                EnableIpamOrganizationAdminAccountResult result = null;

                try {
                    result = executeEnableIpamOrganizationAdminAccount(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableSerialConsoleAccessAsync(EnableSerialConsoleAccessRequest request) {

        return enableSerialConsoleAccessAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableSerialConsoleAccessAsync(final EnableSerialConsoleAccessRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableSerialConsoleAccessRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableSerialConsoleAccessResult call() throws Exception {
                EnableSerialConsoleAccessResult result = null;

                try {
                    result = executeEnableSerialConsoleAccess(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableTransitGatewayRouteTablePropagationAsync(
            EnableTransitGatewayRouteTablePropagationRequest request) {

        return enableTransitGatewayRouteTablePropagationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableTransitGatewayRouteTablePropagationAsync(
            final EnableTransitGatewayRouteTablePropagationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableTransitGatewayRouteTablePropagationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableTransitGatewayRouteTablePropagationResult call() throws Exception {
                EnableTransitGatewayRouteTablePropagationResult result = null;

                try {
                    result = executeEnableTransitGatewayRouteTablePropagation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableVgwRoutePropagationAsync(EnableVgwRoutePropagationRequest request) {

        return enableVgwRoutePropagationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableVgwRoutePropagationAsync(final EnableVgwRoutePropagationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableVgwRoutePropagationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableVgwRoutePropagationResult call() throws Exception {
                EnableVgwRoutePropagationResult result = null;

                try {
                    result = executeEnableVgwRoutePropagation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableVolumeIOAsync(EnableVolumeIORequest request) {

        return enableVolumeIOAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableVolumeIOAsync(final EnableVolumeIORequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableVolumeIORequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableVolumeIOResult call() throws Exception {
                EnableVolumeIOResult result = null;

                try {
                    result = executeEnableVolumeIO(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableVpcClassicLinkAsync(EnableVpcClassicLinkRequest request) {

        return enableVpcClassicLinkAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableVpcClassicLinkAsync(final EnableVpcClassicLinkRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableVpcClassicLinkRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableVpcClassicLinkResult call() throws Exception {
                EnableVpcClassicLinkResult result = null;

                try {
                    result = executeEnableVpcClassicLink(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future enableVpcClassicLinkDnsSupportAsync(EnableVpcClassicLinkDnsSupportRequest request) {

        return enableVpcClassicLinkDnsSupportAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future enableVpcClassicLinkDnsSupportAsync(
            final EnableVpcClassicLinkDnsSupportRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final EnableVpcClassicLinkDnsSupportRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public EnableVpcClassicLinkDnsSupportResult call() throws Exception {
                EnableVpcClassicLinkDnsSupportResult result = null;

                try {
                    result = executeEnableVpcClassicLinkDnsSupport(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future exportClientVpnClientCertificateRevocationListAsync(
            ExportClientVpnClientCertificateRevocationListRequest request) {

        return exportClientVpnClientCertificateRevocationListAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future exportClientVpnClientCertificateRevocationListAsync(
            final ExportClientVpnClientCertificateRevocationListRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ExportClientVpnClientCertificateRevocationListRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ExportClientVpnClientCertificateRevocationListResult call() throws Exception {
                ExportClientVpnClientCertificateRevocationListResult result = null;

                try {
                    result = executeExportClientVpnClientCertificateRevocationList(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future exportClientVpnClientConfigurationAsync(
            ExportClientVpnClientConfigurationRequest request) {

        return exportClientVpnClientConfigurationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future exportClientVpnClientConfigurationAsync(
            final ExportClientVpnClientConfigurationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ExportClientVpnClientConfigurationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ExportClientVpnClientConfigurationResult call() throws Exception {
                ExportClientVpnClientConfigurationResult result = null;

                try {
                    result = executeExportClientVpnClientConfiguration(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future exportImageAsync(ExportImageRequest request) {

        return exportImageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future exportImageAsync(final ExportImageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ExportImageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ExportImageResult call() throws Exception {
                ExportImageResult result = null;

                try {
                    result = executeExportImage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future exportTransitGatewayRoutesAsync(ExportTransitGatewayRoutesRequest request) {

        return exportTransitGatewayRoutesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future exportTransitGatewayRoutesAsync(final ExportTransitGatewayRoutesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ExportTransitGatewayRoutesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ExportTransitGatewayRoutesResult call() throws Exception {
                ExportTransitGatewayRoutesResult result = null;

                try {
                    result = executeExportTransitGatewayRoutes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getAssociatedEnclaveCertificateIamRolesAsync(
            GetAssociatedEnclaveCertificateIamRolesRequest request) {

        return getAssociatedEnclaveCertificateIamRolesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getAssociatedEnclaveCertificateIamRolesAsync(
            final GetAssociatedEnclaveCertificateIamRolesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetAssociatedEnclaveCertificateIamRolesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetAssociatedEnclaveCertificateIamRolesResult call() throws Exception {
                GetAssociatedEnclaveCertificateIamRolesResult result = null;

                try {
                    result = executeGetAssociatedEnclaveCertificateIamRoles(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getAssociatedIpv6PoolCidrsAsync(GetAssociatedIpv6PoolCidrsRequest request) {

        return getAssociatedIpv6PoolCidrsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getAssociatedIpv6PoolCidrsAsync(final GetAssociatedIpv6PoolCidrsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetAssociatedIpv6PoolCidrsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetAssociatedIpv6PoolCidrsResult call() throws Exception {
                GetAssociatedIpv6PoolCidrsResult result = null;

                try {
                    result = executeGetAssociatedIpv6PoolCidrs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getCapacityReservationUsageAsync(GetCapacityReservationUsageRequest request) {

        return getCapacityReservationUsageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getCapacityReservationUsageAsync(final GetCapacityReservationUsageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetCapacityReservationUsageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetCapacityReservationUsageResult call() throws Exception {
                GetCapacityReservationUsageResult result = null;

                try {
                    result = executeGetCapacityReservationUsage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getCoipPoolUsageAsync(GetCoipPoolUsageRequest request) {

        return getCoipPoolUsageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getCoipPoolUsageAsync(final GetCoipPoolUsageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetCoipPoolUsageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetCoipPoolUsageResult call() throws Exception {
                GetCoipPoolUsageResult result = null;

                try {
                    result = executeGetCoipPoolUsage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getConsoleOutputAsync(GetConsoleOutputRequest request) {

        return getConsoleOutputAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getConsoleOutputAsync(final GetConsoleOutputRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetConsoleOutputRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetConsoleOutputResult call() throws Exception {
                GetConsoleOutputResult result = null;

                try {
                    result = executeGetConsoleOutput(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getConsoleScreenshotAsync(GetConsoleScreenshotRequest request) {

        return getConsoleScreenshotAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getConsoleScreenshotAsync(final GetConsoleScreenshotRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetConsoleScreenshotRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetConsoleScreenshotResult call() throws Exception {
                GetConsoleScreenshotResult result = null;

                try {
                    result = executeGetConsoleScreenshot(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getDefaultCreditSpecificationAsync(GetDefaultCreditSpecificationRequest request) {

        return getDefaultCreditSpecificationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getDefaultCreditSpecificationAsync(
            final GetDefaultCreditSpecificationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetDefaultCreditSpecificationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetDefaultCreditSpecificationResult call() throws Exception {
                GetDefaultCreditSpecificationResult result = null;

                try {
                    result = executeGetDefaultCreditSpecification(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getEbsDefaultKmsKeyIdAsync(GetEbsDefaultKmsKeyIdRequest request) {

        return getEbsDefaultKmsKeyIdAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getEbsDefaultKmsKeyIdAsync(final GetEbsDefaultKmsKeyIdRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetEbsDefaultKmsKeyIdRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetEbsDefaultKmsKeyIdResult call() throws Exception {
                GetEbsDefaultKmsKeyIdResult result = null;

                try {
                    result = executeGetEbsDefaultKmsKeyId(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getEbsEncryptionByDefaultAsync(GetEbsEncryptionByDefaultRequest request) {

        return getEbsEncryptionByDefaultAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getEbsEncryptionByDefaultAsync(final GetEbsEncryptionByDefaultRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetEbsEncryptionByDefaultRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetEbsEncryptionByDefaultResult call() throws Exception {
                GetEbsEncryptionByDefaultResult result = null;

                try {
                    result = executeGetEbsEncryptionByDefault(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getFlowLogsIntegrationTemplateAsync(GetFlowLogsIntegrationTemplateRequest request) {

        return getFlowLogsIntegrationTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getFlowLogsIntegrationTemplateAsync(
            final GetFlowLogsIntegrationTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetFlowLogsIntegrationTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetFlowLogsIntegrationTemplateResult call() throws Exception {
                GetFlowLogsIntegrationTemplateResult result = null;

                try {
                    result = executeGetFlowLogsIntegrationTemplate(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getGroupsForCapacityReservationAsync(
            GetGroupsForCapacityReservationRequest request) {

        return getGroupsForCapacityReservationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getGroupsForCapacityReservationAsync(
            final GetGroupsForCapacityReservationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetGroupsForCapacityReservationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetGroupsForCapacityReservationResult call() throws Exception {
                GetGroupsForCapacityReservationResult result = null;

                try {
                    result = executeGetGroupsForCapacityReservation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getHostReservationPurchasePreviewAsync(
            GetHostReservationPurchasePreviewRequest request) {

        return getHostReservationPurchasePreviewAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getHostReservationPurchasePreviewAsync(
            final GetHostReservationPurchasePreviewRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetHostReservationPurchasePreviewRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetHostReservationPurchasePreviewResult call() throws Exception {
                GetHostReservationPurchasePreviewResult result = null;

                try {
                    result = executeGetHostReservationPurchasePreview(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getInstanceTypesFromInstanceRequirementsAsync(
            GetInstanceTypesFromInstanceRequirementsRequest request) {

        return getInstanceTypesFromInstanceRequirementsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getInstanceTypesFromInstanceRequirementsAsync(
            final GetInstanceTypesFromInstanceRequirementsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetInstanceTypesFromInstanceRequirementsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetInstanceTypesFromInstanceRequirementsResult call() throws Exception {
                GetInstanceTypesFromInstanceRequirementsResult result = null;

                try {
                    result = executeGetInstanceTypesFromInstanceRequirements(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getIpamAddressHistoryAsync(GetIpamAddressHistoryRequest request) {

        return getIpamAddressHistoryAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getIpamAddressHistoryAsync(final GetIpamAddressHistoryRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetIpamAddressHistoryRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetIpamAddressHistoryResult call() throws Exception {
                GetIpamAddressHistoryResult result = null;

                try {
                    result = executeGetIpamAddressHistory(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getIpamPoolAllocationsAsync(GetIpamPoolAllocationsRequest request) {

        return getIpamPoolAllocationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getIpamPoolAllocationsAsync(final GetIpamPoolAllocationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetIpamPoolAllocationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetIpamPoolAllocationsResult call() throws Exception {
                GetIpamPoolAllocationsResult result = null;

                try {
                    result = executeGetIpamPoolAllocations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getIpamPoolCidrsAsync(GetIpamPoolCidrsRequest request) {

        return getIpamPoolCidrsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getIpamPoolCidrsAsync(final GetIpamPoolCidrsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetIpamPoolCidrsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetIpamPoolCidrsResult call() throws Exception {
                GetIpamPoolCidrsResult result = null;

                try {
                    result = executeGetIpamPoolCidrs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getIpamResourceCidrsAsync(GetIpamResourceCidrsRequest request) {

        return getIpamResourceCidrsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getIpamResourceCidrsAsync(final GetIpamResourceCidrsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetIpamResourceCidrsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetIpamResourceCidrsResult call() throws Exception {
                GetIpamResourceCidrsResult result = null;

                try {
                    result = executeGetIpamResourceCidrs(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getLaunchTemplateDataAsync(GetLaunchTemplateDataRequest request) {

        return getLaunchTemplateDataAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getLaunchTemplateDataAsync(final GetLaunchTemplateDataRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetLaunchTemplateDataRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetLaunchTemplateDataResult call() throws Exception {
                GetLaunchTemplateDataResult result = null;

                try {
                    result = executeGetLaunchTemplateData(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getManagedPrefixListAssociationsAsync(
            GetManagedPrefixListAssociationsRequest request) {

        return getManagedPrefixListAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getManagedPrefixListAssociationsAsync(
            final GetManagedPrefixListAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetManagedPrefixListAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetManagedPrefixListAssociationsResult call() throws Exception {
                GetManagedPrefixListAssociationsResult result = null;

                try {
                    result = executeGetManagedPrefixListAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getManagedPrefixListEntriesAsync(GetManagedPrefixListEntriesRequest request) {

        return getManagedPrefixListEntriesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getManagedPrefixListEntriesAsync(final GetManagedPrefixListEntriesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetManagedPrefixListEntriesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetManagedPrefixListEntriesResult call() throws Exception {
                GetManagedPrefixListEntriesResult result = null;

                try {
                    result = executeGetManagedPrefixListEntries(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getNetworkInsightsAccessScopeAnalysisFindingsAsync(
            GetNetworkInsightsAccessScopeAnalysisFindingsRequest request) {

        return getNetworkInsightsAccessScopeAnalysisFindingsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getNetworkInsightsAccessScopeAnalysisFindingsAsync(
            final GetNetworkInsightsAccessScopeAnalysisFindingsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetNetworkInsightsAccessScopeAnalysisFindingsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetNetworkInsightsAccessScopeAnalysisFindingsResult call() throws Exception {
                GetNetworkInsightsAccessScopeAnalysisFindingsResult result = null;

                try {
                    result = executeGetNetworkInsightsAccessScopeAnalysisFindings(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getNetworkInsightsAccessScopeContentAsync(
            GetNetworkInsightsAccessScopeContentRequest request) {

        return getNetworkInsightsAccessScopeContentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getNetworkInsightsAccessScopeContentAsync(
            final GetNetworkInsightsAccessScopeContentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetNetworkInsightsAccessScopeContentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetNetworkInsightsAccessScopeContentResult call() throws Exception {
                GetNetworkInsightsAccessScopeContentResult result = null;

                try {
                    result = executeGetNetworkInsightsAccessScopeContent(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getPasswordDataAsync(GetPasswordDataRequest request) {

        return getPasswordDataAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getPasswordDataAsync(final GetPasswordDataRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetPasswordDataRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetPasswordDataResult call() throws Exception {
                GetPasswordDataResult result = null;

                try {
                    result = executeGetPasswordData(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getReservedInstancesExchangeQuoteAsync(
            GetReservedInstancesExchangeQuoteRequest request) {

        return getReservedInstancesExchangeQuoteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getReservedInstancesExchangeQuoteAsync(
            final GetReservedInstancesExchangeQuoteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetReservedInstancesExchangeQuoteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetReservedInstancesExchangeQuoteResult call() throws Exception {
                GetReservedInstancesExchangeQuoteResult result = null;

                try {
                    result = executeGetReservedInstancesExchangeQuote(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getSerialConsoleAccessStatusAsync(GetSerialConsoleAccessStatusRequest request) {

        return getSerialConsoleAccessStatusAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getSerialConsoleAccessStatusAsync(final GetSerialConsoleAccessStatusRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetSerialConsoleAccessStatusRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetSerialConsoleAccessStatusResult call() throws Exception {
                GetSerialConsoleAccessStatusResult result = null;

                try {
                    result = executeGetSerialConsoleAccessStatus(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getSpotPlacementScoresAsync(GetSpotPlacementScoresRequest request) {

        return getSpotPlacementScoresAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getSpotPlacementScoresAsync(final GetSpotPlacementScoresRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetSpotPlacementScoresRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetSpotPlacementScoresResult call() throws Exception {
                GetSpotPlacementScoresResult result = null;

                try {
                    result = executeGetSpotPlacementScores(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getSubnetCidrReservationsAsync(GetSubnetCidrReservationsRequest request) {

        return getSubnetCidrReservationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getSubnetCidrReservationsAsync(final GetSubnetCidrReservationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetSubnetCidrReservationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetSubnetCidrReservationsResult call() throws Exception {
                GetSubnetCidrReservationsResult result = null;

                try {
                    result = executeGetSubnetCidrReservations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayAttachmentPropagationsAsync(
            GetTransitGatewayAttachmentPropagationsRequest request) {

        return getTransitGatewayAttachmentPropagationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayAttachmentPropagationsAsync(
            final GetTransitGatewayAttachmentPropagationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetTransitGatewayAttachmentPropagationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetTransitGatewayAttachmentPropagationsResult call() throws Exception {
                GetTransitGatewayAttachmentPropagationsResult result = null;

                try {
                    result = executeGetTransitGatewayAttachmentPropagations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayMulticastDomainAssociationsAsync(
            GetTransitGatewayMulticastDomainAssociationsRequest request) {

        return getTransitGatewayMulticastDomainAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayMulticastDomainAssociationsAsync(
            final GetTransitGatewayMulticastDomainAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetTransitGatewayMulticastDomainAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetTransitGatewayMulticastDomainAssociationsResult call() throws Exception {
                GetTransitGatewayMulticastDomainAssociationsResult result = null;

                try {
                    result = executeGetTransitGatewayMulticastDomainAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayPrefixListReferencesAsync(
            GetTransitGatewayPrefixListReferencesRequest request) {

        return getTransitGatewayPrefixListReferencesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayPrefixListReferencesAsync(
            final GetTransitGatewayPrefixListReferencesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetTransitGatewayPrefixListReferencesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetTransitGatewayPrefixListReferencesResult call() throws Exception {
                GetTransitGatewayPrefixListReferencesResult result = null;

                try {
                    result = executeGetTransitGatewayPrefixListReferences(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayRouteTableAssociationsAsync(
            GetTransitGatewayRouteTableAssociationsRequest request) {

        return getTransitGatewayRouteTableAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayRouteTableAssociationsAsync(
            final GetTransitGatewayRouteTableAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetTransitGatewayRouteTableAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetTransitGatewayRouteTableAssociationsResult call() throws Exception {
                GetTransitGatewayRouteTableAssociationsResult result = null;

                try {
                    result = executeGetTransitGatewayRouteTableAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayRouteTablePropagationsAsync(
            GetTransitGatewayRouteTablePropagationsRequest request) {

        return getTransitGatewayRouteTablePropagationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getTransitGatewayRouteTablePropagationsAsync(
            final GetTransitGatewayRouteTablePropagationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetTransitGatewayRouteTablePropagationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetTransitGatewayRouteTablePropagationsResult call() throws Exception {
                GetTransitGatewayRouteTablePropagationsResult result = null;

                try {
                    result = executeGetTransitGatewayRouteTablePropagations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getVpnConnectionDeviceSampleConfigurationAsync(
            GetVpnConnectionDeviceSampleConfigurationRequest request) {

        return getVpnConnectionDeviceSampleConfigurationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getVpnConnectionDeviceSampleConfigurationAsync(
            final GetVpnConnectionDeviceSampleConfigurationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetVpnConnectionDeviceSampleConfigurationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetVpnConnectionDeviceSampleConfigurationResult call() throws Exception {
                GetVpnConnectionDeviceSampleConfigurationResult result = null;

                try {
                    result = executeGetVpnConnectionDeviceSampleConfiguration(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future getVpnConnectionDeviceTypesAsync(GetVpnConnectionDeviceTypesRequest request) {

        return getVpnConnectionDeviceTypesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getVpnConnectionDeviceTypesAsync(final GetVpnConnectionDeviceTypesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetVpnConnectionDeviceTypesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetVpnConnectionDeviceTypesResult call() throws Exception {
                GetVpnConnectionDeviceTypesResult result = null;

                try {
                    result = executeGetVpnConnectionDeviceTypes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future importClientVpnClientCertificateRevocationListAsync(
            ImportClientVpnClientCertificateRevocationListRequest request) {

        return importClientVpnClientCertificateRevocationListAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future importClientVpnClientCertificateRevocationListAsync(
            final ImportClientVpnClientCertificateRevocationListRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ImportClientVpnClientCertificateRevocationListRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ImportClientVpnClientCertificateRevocationListResult call() throws Exception {
                ImportClientVpnClientCertificateRevocationListResult result = null;

                try {
                    result = executeImportClientVpnClientCertificateRevocationList(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future importImageAsync(ImportImageRequest request) {

        return importImageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future importImageAsync(final ImportImageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ImportImageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ImportImageResult call() throws Exception {
                ImportImageResult result = null;

                try {
                    result = executeImportImage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the ImportImage operation.
     *
     * @see #importImageAsync(ImportImageRequest)
     */
    @Override
    public java.util.concurrent.Future importImageAsync() {

        return importImageAsync(new ImportImageRequest());
    }

    /**
     * Simplified method form for invoking the ImportImage operation with an AsyncHandler.
     *
     * @see #importImageAsync(ImportImageRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future importImageAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return importImageAsync(new ImportImageRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future importInstanceAsync(ImportInstanceRequest request) {

        return importInstanceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future importInstanceAsync(final ImportInstanceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ImportInstanceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ImportInstanceResult call() throws Exception {
                ImportInstanceResult result = null;

                try {
                    result = executeImportInstance(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future importKeyPairAsync(ImportKeyPairRequest request) {

        return importKeyPairAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future importKeyPairAsync(final ImportKeyPairRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ImportKeyPairRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ImportKeyPairResult call() throws Exception {
                ImportKeyPairResult result = null;

                try {
                    result = executeImportKeyPair(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future importSnapshotAsync(ImportSnapshotRequest request) {

        return importSnapshotAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future importSnapshotAsync(final ImportSnapshotRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ImportSnapshotRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ImportSnapshotResult call() throws Exception {
                ImportSnapshotResult result = null;

                try {
                    result = executeImportSnapshot(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the ImportSnapshot operation.
     *
     * @see #importSnapshotAsync(ImportSnapshotRequest)
     */
    @Override
    public java.util.concurrent.Future importSnapshotAsync() {

        return importSnapshotAsync(new ImportSnapshotRequest());
    }

    /**
     * Simplified method form for invoking the ImportSnapshot operation with an AsyncHandler.
     *
     * @see #importSnapshotAsync(ImportSnapshotRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    public java.util.concurrent.Future importSnapshotAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return importSnapshotAsync(new ImportSnapshotRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future importVolumeAsync(ImportVolumeRequest request) {

        return importVolumeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future importVolumeAsync(final ImportVolumeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ImportVolumeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ImportVolumeResult call() throws Exception {
                ImportVolumeResult result = null;

                try {
                    result = executeImportVolume(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listImagesInRecycleBinAsync(ListImagesInRecycleBinRequest request) {

        return listImagesInRecycleBinAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listImagesInRecycleBinAsync(final ListImagesInRecycleBinRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListImagesInRecycleBinRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListImagesInRecycleBinResult call() throws Exception {
                ListImagesInRecycleBinResult result = null;

                try {
                    result = executeListImagesInRecycleBin(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future listSnapshotsInRecycleBinAsync(ListSnapshotsInRecycleBinRequest request) {

        return listSnapshotsInRecycleBinAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listSnapshotsInRecycleBinAsync(final ListSnapshotsInRecycleBinRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListSnapshotsInRecycleBinRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListSnapshotsInRecycleBinResult call() throws Exception {
                ListSnapshotsInRecycleBinResult result = null;

                try {
                    result = executeListSnapshotsInRecycleBin(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyAddressAttributeAsync(ModifyAddressAttributeRequest request) {

        return modifyAddressAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyAddressAttributeAsync(final ModifyAddressAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyAddressAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyAddressAttributeResult call() throws Exception {
                ModifyAddressAttributeResult result = null;

                try {
                    result = executeModifyAddressAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyAvailabilityZoneGroupAsync(ModifyAvailabilityZoneGroupRequest request) {

        return modifyAvailabilityZoneGroupAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyAvailabilityZoneGroupAsync(final ModifyAvailabilityZoneGroupRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyAvailabilityZoneGroupRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyAvailabilityZoneGroupResult call() throws Exception {
                ModifyAvailabilityZoneGroupResult result = null;

                try {
                    result = executeModifyAvailabilityZoneGroup(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyCapacityReservationAsync(ModifyCapacityReservationRequest request) {

        return modifyCapacityReservationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyCapacityReservationAsync(final ModifyCapacityReservationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyCapacityReservationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyCapacityReservationResult call() throws Exception {
                ModifyCapacityReservationResult result = null;

                try {
                    result = executeModifyCapacityReservation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyCapacityReservationFleetAsync(ModifyCapacityReservationFleetRequest request) {

        return modifyCapacityReservationFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyCapacityReservationFleetAsync(
            final ModifyCapacityReservationFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyCapacityReservationFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyCapacityReservationFleetResult call() throws Exception {
                ModifyCapacityReservationFleetResult result = null;

                try {
                    result = executeModifyCapacityReservationFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyClientVpnEndpointAsync(ModifyClientVpnEndpointRequest request) {

        return modifyClientVpnEndpointAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyClientVpnEndpointAsync(final ModifyClientVpnEndpointRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyClientVpnEndpointRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyClientVpnEndpointResult call() throws Exception {
                ModifyClientVpnEndpointResult result = null;

                try {
                    result = executeModifyClientVpnEndpoint(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyDefaultCreditSpecificationAsync(
            ModifyDefaultCreditSpecificationRequest request) {

        return modifyDefaultCreditSpecificationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyDefaultCreditSpecificationAsync(
            final ModifyDefaultCreditSpecificationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyDefaultCreditSpecificationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyDefaultCreditSpecificationResult call() throws Exception {
                ModifyDefaultCreditSpecificationResult result = null;

                try {
                    result = executeModifyDefaultCreditSpecification(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyEbsDefaultKmsKeyIdAsync(ModifyEbsDefaultKmsKeyIdRequest request) {

        return modifyEbsDefaultKmsKeyIdAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyEbsDefaultKmsKeyIdAsync(final ModifyEbsDefaultKmsKeyIdRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyEbsDefaultKmsKeyIdRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyEbsDefaultKmsKeyIdResult call() throws Exception {
                ModifyEbsDefaultKmsKeyIdResult result = null;

                try {
                    result = executeModifyEbsDefaultKmsKeyId(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyFleetAsync(ModifyFleetRequest request) {

        return modifyFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyFleetAsync(final ModifyFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyFleetResult call() throws Exception {
                ModifyFleetResult result = null;

                try {
                    result = executeModifyFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyFpgaImageAttributeAsync(ModifyFpgaImageAttributeRequest request) {

        return modifyFpgaImageAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyFpgaImageAttributeAsync(final ModifyFpgaImageAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyFpgaImageAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyFpgaImageAttributeResult call() throws Exception {
                ModifyFpgaImageAttributeResult result = null;

                try {
                    result = executeModifyFpgaImageAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyHostsAsync(ModifyHostsRequest request) {

        return modifyHostsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyHostsAsync(final ModifyHostsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyHostsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyHostsResult call() throws Exception {
                ModifyHostsResult result = null;

                try {
                    result = executeModifyHosts(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyIdFormatAsync(ModifyIdFormatRequest request) {

        return modifyIdFormatAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyIdFormatAsync(final ModifyIdFormatRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyIdFormatRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyIdFormatResult call() throws Exception {
                ModifyIdFormatResult result = null;

                try {
                    result = executeModifyIdFormat(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyIdentityIdFormatAsync(ModifyIdentityIdFormatRequest request) {

        return modifyIdentityIdFormatAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyIdentityIdFormatAsync(final ModifyIdentityIdFormatRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyIdentityIdFormatRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyIdentityIdFormatResult call() throws Exception {
                ModifyIdentityIdFormatResult result = null;

                try {
                    result = executeModifyIdentityIdFormat(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyImageAttributeAsync(ModifyImageAttributeRequest request) {

        return modifyImageAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyImageAttributeAsync(final ModifyImageAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyImageAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyImageAttributeResult call() throws Exception {
                ModifyImageAttributeResult result = null;

                try {
                    result = executeModifyImageAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyInstanceAttributeAsync(ModifyInstanceAttributeRequest request) {

        return modifyInstanceAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyInstanceAttributeAsync(final ModifyInstanceAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyInstanceAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyInstanceAttributeResult call() throws Exception {
                ModifyInstanceAttributeResult result = null;

                try {
                    result = executeModifyInstanceAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyInstanceCapacityReservationAttributesAsync(
            ModifyInstanceCapacityReservationAttributesRequest request) {

        return modifyInstanceCapacityReservationAttributesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyInstanceCapacityReservationAttributesAsync(
            final ModifyInstanceCapacityReservationAttributesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyInstanceCapacityReservationAttributesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyInstanceCapacityReservationAttributesResult call() throws Exception {
                ModifyInstanceCapacityReservationAttributesResult result = null;

                try {
                    result = executeModifyInstanceCapacityReservationAttributes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyInstanceCreditSpecificationAsync(
            ModifyInstanceCreditSpecificationRequest request) {

        return modifyInstanceCreditSpecificationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyInstanceCreditSpecificationAsync(
            final ModifyInstanceCreditSpecificationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyInstanceCreditSpecificationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyInstanceCreditSpecificationResult call() throws Exception {
                ModifyInstanceCreditSpecificationResult result = null;

                try {
                    result = executeModifyInstanceCreditSpecification(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyInstanceEventStartTimeAsync(ModifyInstanceEventStartTimeRequest request) {

        return modifyInstanceEventStartTimeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyInstanceEventStartTimeAsync(final ModifyInstanceEventStartTimeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyInstanceEventStartTimeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyInstanceEventStartTimeResult call() throws Exception {
                ModifyInstanceEventStartTimeResult result = null;

                try {
                    result = executeModifyInstanceEventStartTime(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyInstanceEventWindowAsync(ModifyInstanceEventWindowRequest request) {

        return modifyInstanceEventWindowAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyInstanceEventWindowAsync(final ModifyInstanceEventWindowRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyInstanceEventWindowRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyInstanceEventWindowResult call() throws Exception {
                ModifyInstanceEventWindowResult result = null;

                try {
                    result = executeModifyInstanceEventWindow(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyInstanceMetadataOptionsAsync(ModifyInstanceMetadataOptionsRequest request) {

        return modifyInstanceMetadataOptionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyInstanceMetadataOptionsAsync(
            final ModifyInstanceMetadataOptionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyInstanceMetadataOptionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyInstanceMetadataOptionsResult call() throws Exception {
                ModifyInstanceMetadataOptionsResult result = null;

                try {
                    result = executeModifyInstanceMetadataOptions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyInstancePlacementAsync(ModifyInstancePlacementRequest request) {

        return modifyInstancePlacementAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyInstancePlacementAsync(final ModifyInstancePlacementRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyInstancePlacementRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyInstancePlacementResult call() throws Exception {
                ModifyInstancePlacementResult result = null;

                try {
                    result = executeModifyInstancePlacement(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyIpamAsync(ModifyIpamRequest request) {

        return modifyIpamAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyIpamAsync(final ModifyIpamRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyIpamRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyIpamResult call() throws Exception {
                ModifyIpamResult result = null;

                try {
                    result = executeModifyIpam(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyIpamPoolAsync(ModifyIpamPoolRequest request) {

        return modifyIpamPoolAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyIpamPoolAsync(final ModifyIpamPoolRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyIpamPoolRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyIpamPoolResult call() throws Exception {
                ModifyIpamPoolResult result = null;

                try {
                    result = executeModifyIpamPool(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyIpamResourceCidrAsync(ModifyIpamResourceCidrRequest request) {

        return modifyIpamResourceCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyIpamResourceCidrAsync(final ModifyIpamResourceCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyIpamResourceCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyIpamResourceCidrResult call() throws Exception {
                ModifyIpamResourceCidrResult result = null;

                try {
                    result = executeModifyIpamResourceCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyIpamScopeAsync(ModifyIpamScopeRequest request) {

        return modifyIpamScopeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyIpamScopeAsync(final ModifyIpamScopeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyIpamScopeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyIpamScopeResult call() throws Exception {
                ModifyIpamScopeResult result = null;

                try {
                    result = executeModifyIpamScope(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyLaunchTemplateAsync(ModifyLaunchTemplateRequest request) {

        return modifyLaunchTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyLaunchTemplateAsync(final ModifyLaunchTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyLaunchTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyLaunchTemplateResult call() throws Exception {
                ModifyLaunchTemplateResult result = null;

                try {
                    result = executeModifyLaunchTemplate(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyManagedPrefixListAsync(ModifyManagedPrefixListRequest request) {

        return modifyManagedPrefixListAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyManagedPrefixListAsync(final ModifyManagedPrefixListRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyManagedPrefixListRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyManagedPrefixListResult call() throws Exception {
                ModifyManagedPrefixListResult result = null;

                try {
                    result = executeModifyManagedPrefixList(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyNetworkInterfaceAttributeAsync(
            ModifyNetworkInterfaceAttributeRequest request) {

        return modifyNetworkInterfaceAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyNetworkInterfaceAttributeAsync(
            final ModifyNetworkInterfaceAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyNetworkInterfaceAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyNetworkInterfaceAttributeResult call() throws Exception {
                ModifyNetworkInterfaceAttributeResult result = null;

                try {
                    result = executeModifyNetworkInterfaceAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyPrivateDnsNameOptionsAsync(ModifyPrivateDnsNameOptionsRequest request) {

        return modifyPrivateDnsNameOptionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyPrivateDnsNameOptionsAsync(final ModifyPrivateDnsNameOptionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyPrivateDnsNameOptionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyPrivateDnsNameOptionsResult call() throws Exception {
                ModifyPrivateDnsNameOptionsResult result = null;

                try {
                    result = executeModifyPrivateDnsNameOptions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyReservedInstancesAsync(ModifyReservedInstancesRequest request) {

        return modifyReservedInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyReservedInstancesAsync(final ModifyReservedInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyReservedInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyReservedInstancesResult call() throws Exception {
                ModifyReservedInstancesResult result = null;

                try {
                    result = executeModifyReservedInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifySecurityGroupRulesAsync(ModifySecurityGroupRulesRequest request) {

        return modifySecurityGroupRulesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifySecurityGroupRulesAsync(final ModifySecurityGroupRulesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifySecurityGroupRulesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifySecurityGroupRulesResult call() throws Exception {
                ModifySecurityGroupRulesResult result = null;

                try {
                    result = executeModifySecurityGroupRules(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifySnapshotAttributeAsync(ModifySnapshotAttributeRequest request) {

        return modifySnapshotAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifySnapshotAttributeAsync(final ModifySnapshotAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifySnapshotAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifySnapshotAttributeResult call() throws Exception {
                ModifySnapshotAttributeResult result = null;

                try {
                    result = executeModifySnapshotAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifySnapshotTierAsync(ModifySnapshotTierRequest request) {

        return modifySnapshotTierAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifySnapshotTierAsync(final ModifySnapshotTierRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifySnapshotTierRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifySnapshotTierResult call() throws Exception {
                ModifySnapshotTierResult result = null;

                try {
                    result = executeModifySnapshotTier(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifySpotFleetRequestAsync(ModifySpotFleetRequestRequest request) {

        return modifySpotFleetRequestAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifySpotFleetRequestAsync(final ModifySpotFleetRequestRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifySpotFleetRequestRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifySpotFleetRequestResult call() throws Exception {
                ModifySpotFleetRequestResult result = null;

                try {
                    result = executeModifySpotFleetRequest(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifySubnetAttributeAsync(ModifySubnetAttributeRequest request) {

        return modifySubnetAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifySubnetAttributeAsync(final ModifySubnetAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifySubnetAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifySubnetAttributeResult call() throws Exception {
                ModifySubnetAttributeResult result = null;

                try {
                    result = executeModifySubnetAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyTrafficMirrorFilterNetworkServicesAsync(
            ModifyTrafficMirrorFilterNetworkServicesRequest request) {

        return modifyTrafficMirrorFilterNetworkServicesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyTrafficMirrorFilterNetworkServicesAsync(
            final ModifyTrafficMirrorFilterNetworkServicesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyTrafficMirrorFilterNetworkServicesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyTrafficMirrorFilterNetworkServicesResult call() throws Exception {
                ModifyTrafficMirrorFilterNetworkServicesResult result = null;

                try {
                    result = executeModifyTrafficMirrorFilterNetworkServices(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyTrafficMirrorFilterRuleAsync(ModifyTrafficMirrorFilterRuleRequest request) {

        return modifyTrafficMirrorFilterRuleAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyTrafficMirrorFilterRuleAsync(
            final ModifyTrafficMirrorFilterRuleRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyTrafficMirrorFilterRuleRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyTrafficMirrorFilterRuleResult call() throws Exception {
                ModifyTrafficMirrorFilterRuleResult result = null;

                try {
                    result = executeModifyTrafficMirrorFilterRule(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyTrafficMirrorSessionAsync(ModifyTrafficMirrorSessionRequest request) {

        return modifyTrafficMirrorSessionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyTrafficMirrorSessionAsync(final ModifyTrafficMirrorSessionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyTrafficMirrorSessionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyTrafficMirrorSessionResult call() throws Exception {
                ModifyTrafficMirrorSessionResult result = null;

                try {
                    result = executeModifyTrafficMirrorSession(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyTransitGatewayAsync(ModifyTransitGatewayRequest request) {

        return modifyTransitGatewayAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyTransitGatewayAsync(final ModifyTransitGatewayRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyTransitGatewayRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyTransitGatewayResult call() throws Exception {
                ModifyTransitGatewayResult result = null;

                try {
                    result = executeModifyTransitGateway(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyTransitGatewayPrefixListReferenceAsync(
            ModifyTransitGatewayPrefixListReferenceRequest request) {

        return modifyTransitGatewayPrefixListReferenceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyTransitGatewayPrefixListReferenceAsync(
            final ModifyTransitGatewayPrefixListReferenceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyTransitGatewayPrefixListReferenceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyTransitGatewayPrefixListReferenceResult call() throws Exception {
                ModifyTransitGatewayPrefixListReferenceResult result = null;

                try {
                    result = executeModifyTransitGatewayPrefixListReference(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyTransitGatewayVpcAttachmentAsync(
            ModifyTransitGatewayVpcAttachmentRequest request) {

        return modifyTransitGatewayVpcAttachmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyTransitGatewayVpcAttachmentAsync(
            final ModifyTransitGatewayVpcAttachmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyTransitGatewayVpcAttachmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyTransitGatewayVpcAttachmentResult call() throws Exception {
                ModifyTransitGatewayVpcAttachmentResult result = null;

                try {
                    result = executeModifyTransitGatewayVpcAttachment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVolumeAsync(ModifyVolumeRequest request) {

        return modifyVolumeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVolumeAsync(final ModifyVolumeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVolumeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVolumeResult call() throws Exception {
                ModifyVolumeResult result = null;

                try {
                    result = executeModifyVolume(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVolumeAttributeAsync(ModifyVolumeAttributeRequest request) {

        return modifyVolumeAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVolumeAttributeAsync(final ModifyVolumeAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVolumeAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVolumeAttributeResult call() throws Exception {
                ModifyVolumeAttributeResult result = null;

                try {
                    result = executeModifyVolumeAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpcAttributeAsync(ModifyVpcAttributeRequest request) {

        return modifyVpcAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpcAttributeAsync(final ModifyVpcAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpcAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpcAttributeResult call() throws Exception {
                ModifyVpcAttributeResult result = null;

                try {
                    result = executeModifyVpcAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointAsync(ModifyVpcEndpointRequest request) {

        return modifyVpcEndpointAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointAsync(final ModifyVpcEndpointRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpcEndpointRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpcEndpointResult call() throws Exception {
                ModifyVpcEndpointResult result = null;

                try {
                    result = executeModifyVpcEndpoint(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointConnectionNotificationAsync(
            ModifyVpcEndpointConnectionNotificationRequest request) {

        return modifyVpcEndpointConnectionNotificationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointConnectionNotificationAsync(
            final ModifyVpcEndpointConnectionNotificationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpcEndpointConnectionNotificationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpcEndpointConnectionNotificationResult call() throws Exception {
                ModifyVpcEndpointConnectionNotificationResult result = null;

                try {
                    result = executeModifyVpcEndpointConnectionNotification(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointServiceConfigurationAsync(
            ModifyVpcEndpointServiceConfigurationRequest request) {

        return modifyVpcEndpointServiceConfigurationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointServiceConfigurationAsync(
            final ModifyVpcEndpointServiceConfigurationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpcEndpointServiceConfigurationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpcEndpointServiceConfigurationResult call() throws Exception {
                ModifyVpcEndpointServiceConfigurationResult result = null;

                try {
                    result = executeModifyVpcEndpointServiceConfiguration(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointServicePayerResponsibilityAsync(
            ModifyVpcEndpointServicePayerResponsibilityRequest request) {

        return modifyVpcEndpointServicePayerResponsibilityAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointServicePayerResponsibilityAsync(
            final ModifyVpcEndpointServicePayerResponsibilityRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpcEndpointServicePayerResponsibilityRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpcEndpointServicePayerResponsibilityResult call() throws Exception {
                ModifyVpcEndpointServicePayerResponsibilityResult result = null;

                try {
                    result = executeModifyVpcEndpointServicePayerResponsibility(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointServicePermissionsAsync(
            ModifyVpcEndpointServicePermissionsRequest request) {

        return modifyVpcEndpointServicePermissionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpcEndpointServicePermissionsAsync(
            final ModifyVpcEndpointServicePermissionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpcEndpointServicePermissionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpcEndpointServicePermissionsResult call() throws Exception {
                ModifyVpcEndpointServicePermissionsResult result = null;

                try {
                    result = executeModifyVpcEndpointServicePermissions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpcPeeringConnectionOptionsAsync(
            ModifyVpcPeeringConnectionOptionsRequest request) {

        return modifyVpcPeeringConnectionOptionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpcPeeringConnectionOptionsAsync(
            final ModifyVpcPeeringConnectionOptionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpcPeeringConnectionOptionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpcPeeringConnectionOptionsResult call() throws Exception {
                ModifyVpcPeeringConnectionOptionsResult result = null;

                try {
                    result = executeModifyVpcPeeringConnectionOptions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpcTenancyAsync(ModifyVpcTenancyRequest request) {

        return modifyVpcTenancyAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpcTenancyAsync(final ModifyVpcTenancyRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpcTenancyRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpcTenancyResult call() throws Exception {
                ModifyVpcTenancyResult result = null;

                try {
                    result = executeModifyVpcTenancy(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpnConnectionAsync(ModifyVpnConnectionRequest request) {

        return modifyVpnConnectionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpnConnectionAsync(final ModifyVpnConnectionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpnConnectionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpnConnectionResult call() throws Exception {
                ModifyVpnConnectionResult result = null;

                try {
                    result = executeModifyVpnConnection(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpnConnectionOptionsAsync(ModifyVpnConnectionOptionsRequest request) {

        return modifyVpnConnectionOptionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpnConnectionOptionsAsync(final ModifyVpnConnectionOptionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpnConnectionOptionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpnConnectionOptionsResult call() throws Exception {
                ModifyVpnConnectionOptionsResult result = null;

                try {
                    result = executeModifyVpnConnectionOptions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpnTunnelCertificateAsync(ModifyVpnTunnelCertificateRequest request) {

        return modifyVpnTunnelCertificateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpnTunnelCertificateAsync(final ModifyVpnTunnelCertificateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpnTunnelCertificateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpnTunnelCertificateResult call() throws Exception {
                ModifyVpnTunnelCertificateResult result = null;

                try {
                    result = executeModifyVpnTunnelCertificate(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future modifyVpnTunnelOptionsAsync(ModifyVpnTunnelOptionsRequest request) {

        return modifyVpnTunnelOptionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future modifyVpnTunnelOptionsAsync(final ModifyVpnTunnelOptionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ModifyVpnTunnelOptionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ModifyVpnTunnelOptionsResult call() throws Exception {
                ModifyVpnTunnelOptionsResult result = null;

                try {
                    result = executeModifyVpnTunnelOptions(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future monitorInstancesAsync(MonitorInstancesRequest request) {

        return monitorInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future monitorInstancesAsync(final MonitorInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final MonitorInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public MonitorInstancesResult call() throws Exception {
                MonitorInstancesResult result = null;

                try {
                    result = executeMonitorInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future moveAddressToVpcAsync(MoveAddressToVpcRequest request) {

        return moveAddressToVpcAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future moveAddressToVpcAsync(final MoveAddressToVpcRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final MoveAddressToVpcRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public MoveAddressToVpcResult call() throws Exception {
                MoveAddressToVpcResult result = null;

                try {
                    result = executeMoveAddressToVpc(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future moveByoipCidrToIpamAsync(MoveByoipCidrToIpamRequest request) {

        return moveByoipCidrToIpamAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future moveByoipCidrToIpamAsync(final MoveByoipCidrToIpamRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final MoveByoipCidrToIpamRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public MoveByoipCidrToIpamResult call() throws Exception {
                MoveByoipCidrToIpamResult result = null;

                try {
                    result = executeMoveByoipCidrToIpam(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future provisionByoipCidrAsync(ProvisionByoipCidrRequest request) {

        return provisionByoipCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future provisionByoipCidrAsync(final ProvisionByoipCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ProvisionByoipCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ProvisionByoipCidrResult call() throws Exception {
                ProvisionByoipCidrResult result = null;

                try {
                    result = executeProvisionByoipCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future provisionIpamPoolCidrAsync(ProvisionIpamPoolCidrRequest request) {

        return provisionIpamPoolCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future provisionIpamPoolCidrAsync(final ProvisionIpamPoolCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ProvisionIpamPoolCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ProvisionIpamPoolCidrResult call() throws Exception {
                ProvisionIpamPoolCidrResult result = null;

                try {
                    result = executeProvisionIpamPoolCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future provisionPublicIpv4PoolCidrAsync(ProvisionPublicIpv4PoolCidrRequest request) {

        return provisionPublicIpv4PoolCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future provisionPublicIpv4PoolCidrAsync(final ProvisionPublicIpv4PoolCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ProvisionPublicIpv4PoolCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ProvisionPublicIpv4PoolCidrResult call() throws Exception {
                ProvisionPublicIpv4PoolCidrResult result = null;

                try {
                    result = executeProvisionPublicIpv4PoolCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future purchaseHostReservationAsync(PurchaseHostReservationRequest request) {

        return purchaseHostReservationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future purchaseHostReservationAsync(final PurchaseHostReservationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final PurchaseHostReservationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public PurchaseHostReservationResult call() throws Exception {
                PurchaseHostReservationResult result = null;

                try {
                    result = executePurchaseHostReservation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future purchaseReservedInstancesOfferingAsync(
            PurchaseReservedInstancesOfferingRequest request) {

        return purchaseReservedInstancesOfferingAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future purchaseReservedInstancesOfferingAsync(
            final PurchaseReservedInstancesOfferingRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final PurchaseReservedInstancesOfferingRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public PurchaseReservedInstancesOfferingResult call() throws Exception {
                PurchaseReservedInstancesOfferingResult result = null;

                try {
                    result = executePurchaseReservedInstancesOffering(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future purchaseScheduledInstancesAsync(PurchaseScheduledInstancesRequest request) {

        return purchaseScheduledInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future purchaseScheduledInstancesAsync(final PurchaseScheduledInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final PurchaseScheduledInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public PurchaseScheduledInstancesResult call() throws Exception {
                PurchaseScheduledInstancesResult result = null;

                try {
                    result = executePurchaseScheduledInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future rebootInstancesAsync(RebootInstancesRequest request) {

        return rebootInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future rebootInstancesAsync(final RebootInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RebootInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RebootInstancesResult call() throws Exception {
                RebootInstancesResult result = null;

                try {
                    result = executeRebootInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future registerImageAsync(RegisterImageRequest request) {

        return registerImageAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future registerImageAsync(final RegisterImageRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RegisterImageRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RegisterImageResult call() throws Exception {
                RegisterImageResult result = null;

                try {
                    result = executeRegisterImage(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future registerInstanceEventNotificationAttributesAsync(
            RegisterInstanceEventNotificationAttributesRequest request) {

        return registerInstanceEventNotificationAttributesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future registerInstanceEventNotificationAttributesAsync(
            final RegisterInstanceEventNotificationAttributesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RegisterInstanceEventNotificationAttributesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RegisterInstanceEventNotificationAttributesResult call() throws Exception {
                RegisterInstanceEventNotificationAttributesResult result = null;

                try {
                    result = executeRegisterInstanceEventNotificationAttributes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future registerTransitGatewayMulticastGroupMembersAsync(
            RegisterTransitGatewayMulticastGroupMembersRequest request) {

        return registerTransitGatewayMulticastGroupMembersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future registerTransitGatewayMulticastGroupMembersAsync(
            final RegisterTransitGatewayMulticastGroupMembersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RegisterTransitGatewayMulticastGroupMembersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RegisterTransitGatewayMulticastGroupMembersResult call() throws Exception {
                RegisterTransitGatewayMulticastGroupMembersResult result = null;

                try {
                    result = executeRegisterTransitGatewayMulticastGroupMembers(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future registerTransitGatewayMulticastGroupSourcesAsync(
            RegisterTransitGatewayMulticastGroupSourcesRequest request) {

        return registerTransitGatewayMulticastGroupSourcesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future registerTransitGatewayMulticastGroupSourcesAsync(
            final RegisterTransitGatewayMulticastGroupSourcesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RegisterTransitGatewayMulticastGroupSourcesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RegisterTransitGatewayMulticastGroupSourcesResult call() throws Exception {
                RegisterTransitGatewayMulticastGroupSourcesResult result = null;

                try {
                    result = executeRegisterTransitGatewayMulticastGroupSources(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future rejectTransitGatewayMulticastDomainAssociationsAsync(
            RejectTransitGatewayMulticastDomainAssociationsRequest request) {

        return rejectTransitGatewayMulticastDomainAssociationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future rejectTransitGatewayMulticastDomainAssociationsAsync(
            final RejectTransitGatewayMulticastDomainAssociationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RejectTransitGatewayMulticastDomainAssociationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RejectTransitGatewayMulticastDomainAssociationsResult call() throws Exception {
                RejectTransitGatewayMulticastDomainAssociationsResult result = null;

                try {
                    result = executeRejectTransitGatewayMulticastDomainAssociations(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future rejectTransitGatewayPeeringAttachmentAsync(
            RejectTransitGatewayPeeringAttachmentRequest request) {

        return rejectTransitGatewayPeeringAttachmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future rejectTransitGatewayPeeringAttachmentAsync(
            final RejectTransitGatewayPeeringAttachmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RejectTransitGatewayPeeringAttachmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RejectTransitGatewayPeeringAttachmentResult call() throws Exception {
                RejectTransitGatewayPeeringAttachmentResult result = null;

                try {
                    result = executeRejectTransitGatewayPeeringAttachment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future rejectTransitGatewayVpcAttachmentAsync(
            RejectTransitGatewayVpcAttachmentRequest request) {

        return rejectTransitGatewayVpcAttachmentAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future rejectTransitGatewayVpcAttachmentAsync(
            final RejectTransitGatewayVpcAttachmentRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RejectTransitGatewayVpcAttachmentRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RejectTransitGatewayVpcAttachmentResult call() throws Exception {
                RejectTransitGatewayVpcAttachmentResult result = null;

                try {
                    result = executeRejectTransitGatewayVpcAttachment(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future rejectVpcEndpointConnectionsAsync(RejectVpcEndpointConnectionsRequest request) {

        return rejectVpcEndpointConnectionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future rejectVpcEndpointConnectionsAsync(final RejectVpcEndpointConnectionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RejectVpcEndpointConnectionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RejectVpcEndpointConnectionsResult call() throws Exception {
                RejectVpcEndpointConnectionsResult result = null;

                try {
                    result = executeRejectVpcEndpointConnections(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future rejectVpcPeeringConnectionAsync(RejectVpcPeeringConnectionRequest request) {

        return rejectVpcPeeringConnectionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future rejectVpcPeeringConnectionAsync(final RejectVpcPeeringConnectionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RejectVpcPeeringConnectionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RejectVpcPeeringConnectionResult call() throws Exception {
                RejectVpcPeeringConnectionResult result = null;

                try {
                    result = executeRejectVpcPeeringConnection(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future releaseAddressAsync(ReleaseAddressRequest request) {

        return releaseAddressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future releaseAddressAsync(final ReleaseAddressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReleaseAddressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReleaseAddressResult call() throws Exception {
                ReleaseAddressResult result = null;

                try {
                    result = executeReleaseAddress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future releaseHostsAsync(ReleaseHostsRequest request) {

        return releaseHostsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future releaseHostsAsync(final ReleaseHostsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReleaseHostsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReleaseHostsResult call() throws Exception {
                ReleaseHostsResult result = null;

                try {
                    result = executeReleaseHosts(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future releaseIpamPoolAllocationAsync(ReleaseIpamPoolAllocationRequest request) {

        return releaseIpamPoolAllocationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future releaseIpamPoolAllocationAsync(final ReleaseIpamPoolAllocationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReleaseIpamPoolAllocationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReleaseIpamPoolAllocationResult call() throws Exception {
                ReleaseIpamPoolAllocationResult result = null;

                try {
                    result = executeReleaseIpamPoolAllocation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future replaceIamInstanceProfileAssociationAsync(
            ReplaceIamInstanceProfileAssociationRequest request) {

        return replaceIamInstanceProfileAssociationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future replaceIamInstanceProfileAssociationAsync(
            final ReplaceIamInstanceProfileAssociationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReplaceIamInstanceProfileAssociationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReplaceIamInstanceProfileAssociationResult call() throws Exception {
                ReplaceIamInstanceProfileAssociationResult result = null;

                try {
                    result = executeReplaceIamInstanceProfileAssociation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future replaceNetworkAclAssociationAsync(ReplaceNetworkAclAssociationRequest request) {

        return replaceNetworkAclAssociationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future replaceNetworkAclAssociationAsync(final ReplaceNetworkAclAssociationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReplaceNetworkAclAssociationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReplaceNetworkAclAssociationResult call() throws Exception {
                ReplaceNetworkAclAssociationResult result = null;

                try {
                    result = executeReplaceNetworkAclAssociation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future replaceNetworkAclEntryAsync(ReplaceNetworkAclEntryRequest request) {

        return replaceNetworkAclEntryAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future replaceNetworkAclEntryAsync(final ReplaceNetworkAclEntryRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReplaceNetworkAclEntryRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReplaceNetworkAclEntryResult call() throws Exception {
                ReplaceNetworkAclEntryResult result = null;

                try {
                    result = executeReplaceNetworkAclEntry(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future replaceRouteAsync(ReplaceRouteRequest request) {

        return replaceRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future replaceRouteAsync(final ReplaceRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReplaceRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReplaceRouteResult call() throws Exception {
                ReplaceRouteResult result = null;

                try {
                    result = executeReplaceRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future replaceRouteTableAssociationAsync(ReplaceRouteTableAssociationRequest request) {

        return replaceRouteTableAssociationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future replaceRouteTableAssociationAsync(final ReplaceRouteTableAssociationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReplaceRouteTableAssociationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReplaceRouteTableAssociationResult call() throws Exception {
                ReplaceRouteTableAssociationResult result = null;

                try {
                    result = executeReplaceRouteTableAssociation(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future replaceTransitGatewayRouteAsync(ReplaceTransitGatewayRouteRequest request) {

        return replaceTransitGatewayRouteAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future replaceTransitGatewayRouteAsync(final ReplaceTransitGatewayRouteRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReplaceTransitGatewayRouteRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReplaceTransitGatewayRouteResult call() throws Exception {
                ReplaceTransitGatewayRouteResult result = null;

                try {
                    result = executeReplaceTransitGatewayRoute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future reportInstanceStatusAsync(ReportInstanceStatusRequest request) {

        return reportInstanceStatusAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future reportInstanceStatusAsync(final ReportInstanceStatusRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ReportInstanceStatusRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ReportInstanceStatusResult call() throws Exception {
                ReportInstanceStatusResult result = null;

                try {
                    result = executeReportInstanceStatus(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future requestSpotFleetAsync(RequestSpotFleetRequest request) {

        return requestSpotFleetAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future requestSpotFleetAsync(final RequestSpotFleetRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RequestSpotFleetRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RequestSpotFleetResult call() throws Exception {
                RequestSpotFleetResult result = null;

                try {
                    result = executeRequestSpotFleet(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future requestSpotInstancesAsync(RequestSpotInstancesRequest request) {

        return requestSpotInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future requestSpotInstancesAsync(final RequestSpotInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RequestSpotInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RequestSpotInstancesResult call() throws Exception {
                RequestSpotInstancesResult result = null;

                try {
                    result = executeRequestSpotInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future resetAddressAttributeAsync(ResetAddressAttributeRequest request) {

        return resetAddressAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future resetAddressAttributeAsync(final ResetAddressAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ResetAddressAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ResetAddressAttributeResult call() throws Exception {
                ResetAddressAttributeResult result = null;

                try {
                    result = executeResetAddressAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future resetEbsDefaultKmsKeyIdAsync(ResetEbsDefaultKmsKeyIdRequest request) {

        return resetEbsDefaultKmsKeyIdAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future resetEbsDefaultKmsKeyIdAsync(final ResetEbsDefaultKmsKeyIdRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ResetEbsDefaultKmsKeyIdRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ResetEbsDefaultKmsKeyIdResult call() throws Exception {
                ResetEbsDefaultKmsKeyIdResult result = null;

                try {
                    result = executeResetEbsDefaultKmsKeyId(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future resetFpgaImageAttributeAsync(ResetFpgaImageAttributeRequest request) {

        return resetFpgaImageAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future resetFpgaImageAttributeAsync(final ResetFpgaImageAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ResetFpgaImageAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ResetFpgaImageAttributeResult call() throws Exception {
                ResetFpgaImageAttributeResult result = null;

                try {
                    result = executeResetFpgaImageAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future resetImageAttributeAsync(ResetImageAttributeRequest request) {

        return resetImageAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future resetImageAttributeAsync(final ResetImageAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ResetImageAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ResetImageAttributeResult call() throws Exception {
                ResetImageAttributeResult result = null;

                try {
                    result = executeResetImageAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future resetInstanceAttributeAsync(ResetInstanceAttributeRequest request) {

        return resetInstanceAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future resetInstanceAttributeAsync(final ResetInstanceAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ResetInstanceAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ResetInstanceAttributeResult call() throws Exception {
                ResetInstanceAttributeResult result = null;

                try {
                    result = executeResetInstanceAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future resetNetworkInterfaceAttributeAsync(ResetNetworkInterfaceAttributeRequest request) {

        return resetNetworkInterfaceAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future resetNetworkInterfaceAttributeAsync(
            final ResetNetworkInterfaceAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ResetNetworkInterfaceAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ResetNetworkInterfaceAttributeResult call() throws Exception {
                ResetNetworkInterfaceAttributeResult result = null;

                try {
                    result = executeResetNetworkInterfaceAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future resetSnapshotAttributeAsync(ResetSnapshotAttributeRequest request) {

        return resetSnapshotAttributeAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future resetSnapshotAttributeAsync(final ResetSnapshotAttributeRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ResetSnapshotAttributeRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ResetSnapshotAttributeResult call() throws Exception {
                ResetSnapshotAttributeResult result = null;

                try {
                    result = executeResetSnapshotAttribute(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future restoreAddressToClassicAsync(RestoreAddressToClassicRequest request) {

        return restoreAddressToClassicAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future restoreAddressToClassicAsync(final RestoreAddressToClassicRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RestoreAddressToClassicRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RestoreAddressToClassicResult call() throws Exception {
                RestoreAddressToClassicResult result = null;

                try {
                    result = executeRestoreAddressToClassic(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future restoreImageFromRecycleBinAsync(RestoreImageFromRecycleBinRequest request) {

        return restoreImageFromRecycleBinAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future restoreImageFromRecycleBinAsync(final RestoreImageFromRecycleBinRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RestoreImageFromRecycleBinRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RestoreImageFromRecycleBinResult call() throws Exception {
                RestoreImageFromRecycleBinResult result = null;

                try {
                    result = executeRestoreImageFromRecycleBin(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future restoreManagedPrefixListVersionAsync(
            RestoreManagedPrefixListVersionRequest request) {

        return restoreManagedPrefixListVersionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future restoreManagedPrefixListVersionAsync(
            final RestoreManagedPrefixListVersionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RestoreManagedPrefixListVersionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RestoreManagedPrefixListVersionResult call() throws Exception {
                RestoreManagedPrefixListVersionResult result = null;

                try {
                    result = executeRestoreManagedPrefixListVersion(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future restoreSnapshotFromRecycleBinAsync(RestoreSnapshotFromRecycleBinRequest request) {

        return restoreSnapshotFromRecycleBinAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future restoreSnapshotFromRecycleBinAsync(
            final RestoreSnapshotFromRecycleBinRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RestoreSnapshotFromRecycleBinRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RestoreSnapshotFromRecycleBinResult call() throws Exception {
                RestoreSnapshotFromRecycleBinResult result = null;

                try {
                    result = executeRestoreSnapshotFromRecycleBin(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future restoreSnapshotTierAsync(RestoreSnapshotTierRequest request) {

        return restoreSnapshotTierAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future restoreSnapshotTierAsync(final RestoreSnapshotTierRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RestoreSnapshotTierRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RestoreSnapshotTierResult call() throws Exception {
                RestoreSnapshotTierResult result = null;

                try {
                    result = executeRestoreSnapshotTier(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future revokeClientVpnIngressAsync(RevokeClientVpnIngressRequest request) {

        return revokeClientVpnIngressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future revokeClientVpnIngressAsync(final RevokeClientVpnIngressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RevokeClientVpnIngressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RevokeClientVpnIngressResult call() throws Exception {
                RevokeClientVpnIngressResult result = null;

                try {
                    result = executeRevokeClientVpnIngress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future revokeSecurityGroupEgressAsync(RevokeSecurityGroupEgressRequest request) {

        return revokeSecurityGroupEgressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future revokeSecurityGroupEgressAsync(final RevokeSecurityGroupEgressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RevokeSecurityGroupEgressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RevokeSecurityGroupEgressResult call() throws Exception {
                RevokeSecurityGroupEgressResult result = null;

                try {
                    result = executeRevokeSecurityGroupEgress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future revokeSecurityGroupIngressAsync(RevokeSecurityGroupIngressRequest request) {

        return revokeSecurityGroupIngressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future revokeSecurityGroupIngressAsync(final RevokeSecurityGroupIngressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RevokeSecurityGroupIngressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RevokeSecurityGroupIngressResult call() throws Exception {
                RevokeSecurityGroupIngressResult result = null;

                try {
                    result = executeRevokeSecurityGroupIngress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Simplified method form for invoking the RevokeSecurityGroupIngress operation.
     *
     * @see #revokeSecurityGroupIngressAsync(RevokeSecurityGroupIngressRequest)
     */
    @Override
    @Deprecated
    public java.util.concurrent.Future revokeSecurityGroupIngressAsync() {

        return revokeSecurityGroupIngressAsync(new RevokeSecurityGroupIngressRequest());
    }

    /**
     * Simplified method form for invoking the RevokeSecurityGroupIngress operation with an AsyncHandler.
     *
     * @see #revokeSecurityGroupIngressAsync(RevokeSecurityGroupIngressRequest, com.amazonaws.handlers.AsyncHandler)
     */
    @Override
    @Deprecated
    public java.util.concurrent.Future revokeSecurityGroupIngressAsync(
            com.amazonaws.handlers.AsyncHandler asyncHandler) {

        return revokeSecurityGroupIngressAsync(new RevokeSecurityGroupIngressRequest(), asyncHandler);
    }

    @Override
    public java.util.concurrent.Future runInstancesAsync(RunInstancesRequest request) {

        return runInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future runInstancesAsync(final RunInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RunInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RunInstancesResult call() throws Exception {
                RunInstancesResult result = null;

                try {
                    result = executeRunInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future runScheduledInstancesAsync(RunScheduledInstancesRequest request) {

        return runScheduledInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future runScheduledInstancesAsync(final RunScheduledInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final RunScheduledInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public RunScheduledInstancesResult call() throws Exception {
                RunScheduledInstancesResult result = null;

                try {
                    result = executeRunScheduledInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchLocalGatewayRoutesAsync(SearchLocalGatewayRoutesRequest request) {

        return searchLocalGatewayRoutesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchLocalGatewayRoutesAsync(final SearchLocalGatewayRoutesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchLocalGatewayRoutesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchLocalGatewayRoutesResult call() throws Exception {
                SearchLocalGatewayRoutesResult result = null;

                try {
                    result = executeSearchLocalGatewayRoutes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchTransitGatewayMulticastGroupsAsync(
            SearchTransitGatewayMulticastGroupsRequest request) {

        return searchTransitGatewayMulticastGroupsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchTransitGatewayMulticastGroupsAsync(
            final SearchTransitGatewayMulticastGroupsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchTransitGatewayMulticastGroupsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchTransitGatewayMulticastGroupsResult call() throws Exception {
                SearchTransitGatewayMulticastGroupsResult result = null;

                try {
                    result = executeSearchTransitGatewayMulticastGroups(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future searchTransitGatewayRoutesAsync(SearchTransitGatewayRoutesRequest request) {

        return searchTransitGatewayRoutesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future searchTransitGatewayRoutesAsync(final SearchTransitGatewayRoutesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SearchTransitGatewayRoutesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SearchTransitGatewayRoutesResult call() throws Exception {
                SearchTransitGatewayRoutesResult result = null;

                try {
                    result = executeSearchTransitGatewayRoutes(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future sendDiagnosticInterruptAsync(SendDiagnosticInterruptRequest request) {

        return sendDiagnosticInterruptAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future sendDiagnosticInterruptAsync(final SendDiagnosticInterruptRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final SendDiagnosticInterruptRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public SendDiagnosticInterruptResult call() throws Exception {
                SendDiagnosticInterruptResult result = null;

                try {
                    result = executeSendDiagnosticInterrupt(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future startInstancesAsync(StartInstancesRequest request) {

        return startInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future startInstancesAsync(final StartInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final StartInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public StartInstancesResult call() throws Exception {
                StartInstancesResult result = null;

                try {
                    result = executeStartInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future startNetworkInsightsAccessScopeAnalysisAsync(
            StartNetworkInsightsAccessScopeAnalysisRequest request) {

        return startNetworkInsightsAccessScopeAnalysisAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future startNetworkInsightsAccessScopeAnalysisAsync(
            final StartNetworkInsightsAccessScopeAnalysisRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final StartNetworkInsightsAccessScopeAnalysisRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public StartNetworkInsightsAccessScopeAnalysisResult call() throws Exception {
                StartNetworkInsightsAccessScopeAnalysisResult result = null;

                try {
                    result = executeStartNetworkInsightsAccessScopeAnalysis(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future startNetworkInsightsAnalysisAsync(StartNetworkInsightsAnalysisRequest request) {

        return startNetworkInsightsAnalysisAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future startNetworkInsightsAnalysisAsync(final StartNetworkInsightsAnalysisRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final StartNetworkInsightsAnalysisRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public StartNetworkInsightsAnalysisResult call() throws Exception {
                StartNetworkInsightsAnalysisResult result = null;

                try {
                    result = executeStartNetworkInsightsAnalysis(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future startVpcEndpointServicePrivateDnsVerificationAsync(
            StartVpcEndpointServicePrivateDnsVerificationRequest request) {

        return startVpcEndpointServicePrivateDnsVerificationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future startVpcEndpointServicePrivateDnsVerificationAsync(
            final StartVpcEndpointServicePrivateDnsVerificationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final StartVpcEndpointServicePrivateDnsVerificationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public StartVpcEndpointServicePrivateDnsVerificationResult call() throws Exception {
                StartVpcEndpointServicePrivateDnsVerificationResult result = null;

                try {
                    result = executeStartVpcEndpointServicePrivateDnsVerification(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future stopInstancesAsync(StopInstancesRequest request) {

        return stopInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future stopInstancesAsync(final StopInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final StopInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public StopInstancesResult call() throws Exception {
                StopInstancesResult result = null;

                try {
                    result = executeStopInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future terminateClientVpnConnectionsAsync(TerminateClientVpnConnectionsRequest request) {

        return terminateClientVpnConnectionsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future terminateClientVpnConnectionsAsync(
            final TerminateClientVpnConnectionsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final TerminateClientVpnConnectionsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public TerminateClientVpnConnectionsResult call() throws Exception {
                TerminateClientVpnConnectionsResult result = null;

                try {
                    result = executeTerminateClientVpnConnections(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future terminateInstancesAsync(TerminateInstancesRequest request) {

        return terminateInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future terminateInstancesAsync(final TerminateInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final TerminateInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public TerminateInstancesResult call() throws Exception {
                TerminateInstancesResult result = null;

                try {
                    result = executeTerminateInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future unassignIpv6AddressesAsync(UnassignIpv6AddressesRequest request) {

        return unassignIpv6AddressesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future unassignIpv6AddressesAsync(final UnassignIpv6AddressesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UnassignIpv6AddressesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UnassignIpv6AddressesResult call() throws Exception {
                UnassignIpv6AddressesResult result = null;

                try {
                    result = executeUnassignIpv6Addresses(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future unassignPrivateIpAddressesAsync(UnassignPrivateIpAddressesRequest request) {

        return unassignPrivateIpAddressesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future unassignPrivateIpAddressesAsync(final UnassignPrivateIpAddressesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UnassignPrivateIpAddressesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UnassignPrivateIpAddressesResult call() throws Exception {
                UnassignPrivateIpAddressesResult result = null;

                try {
                    result = executeUnassignPrivateIpAddresses(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future unmonitorInstancesAsync(UnmonitorInstancesRequest request) {

        return unmonitorInstancesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future unmonitorInstancesAsync(final UnmonitorInstancesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UnmonitorInstancesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UnmonitorInstancesResult call() throws Exception {
                UnmonitorInstancesResult result = null;

                try {
                    result = executeUnmonitorInstances(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateSecurityGroupRuleDescriptionsEgressAsync(
            UpdateSecurityGroupRuleDescriptionsEgressRequest request) {

        return updateSecurityGroupRuleDescriptionsEgressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateSecurityGroupRuleDescriptionsEgressAsync(
            final UpdateSecurityGroupRuleDescriptionsEgressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateSecurityGroupRuleDescriptionsEgressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateSecurityGroupRuleDescriptionsEgressResult call() throws Exception {
                UpdateSecurityGroupRuleDescriptionsEgressResult result = null;

                try {
                    result = executeUpdateSecurityGroupRuleDescriptionsEgress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future updateSecurityGroupRuleDescriptionsIngressAsync(
            UpdateSecurityGroupRuleDescriptionsIngressRequest request) {

        return updateSecurityGroupRuleDescriptionsIngressAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateSecurityGroupRuleDescriptionsIngressAsync(
            final UpdateSecurityGroupRuleDescriptionsIngressRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateSecurityGroupRuleDescriptionsIngressRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateSecurityGroupRuleDescriptionsIngressResult call() throws Exception {
                UpdateSecurityGroupRuleDescriptionsIngressResult result = null;

                try {
                    result = executeUpdateSecurityGroupRuleDescriptionsIngress(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    @Override
    public java.util.concurrent.Future withdrawByoipCidrAsync(WithdrawByoipCidrRequest request) {

        return withdrawByoipCidrAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future withdrawByoipCidrAsync(final WithdrawByoipCidrRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final WithdrawByoipCidrRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public WithdrawByoipCidrResult call() throws Exception {
                WithdrawByoipCidrResult result = null;

                try {
                    result = executeWithdrawByoipCidr(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending
     * asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should
     * call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to
     * calling this method.
     */
    @Override
    public void shutdown() {
        super.shutdown();
        executorService.shutdownNow();
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy