• Home
• com.amazonaws
• aws-java-sdk-iotwireless
• 1.12.780
• source code
• AWSIoTWirelessAsyncClient.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.amazonaws.services.iotwireless.AWSIoTWirelessAsyncClient Maven / Gradle / Ivy

/*
 * Copyright 2019-2024 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.iotwireless;

import javax.annotation.Generated;

import com.amazonaws.services.iotwireless.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;

import java.util.concurrent.ExecutorService;

/**
 * Client for accessing AWS IoT Wireless 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.
 * 

 * 

 * AWS IoT Wireless provides bi-directional communication between internet-connected wireless devices and the AWS Cloud.
 * To onboard both LoRaWAN and Sidewalk devices to AWS IoT, use the IoT Wireless API. These wireless devices use the Low
 * Power Wide Area Networking (LPWAN) communication protocol to communicate with AWS IoT.
 * 
 * 

 * Using the API, you can perform create, read, update, and delete operations for your wireless devices, gateways,
 * destinations, and profiles. After onboarding your devices, you can use the API operations to set log levels and
 * monitor your devices with CloudWatch.
 * 
 * 

 * You can also use the API operations to create multicast groups and schedule a multicast session for sending a
 * downlink message to devices in the group. By using Firmware Updates Over-The-Air (FUOTA) API operations, you can
 * create a FUOTA task and schedule a session to update the firmware of individual devices or an entire group of devices
 * in a multicast group.
 * 
 * 

 * To connect to the AWS IoT Wireless Service, use the Service endpoints as described in IoT Wireless Service
 * endpoints in the AWS General Reference.
 * 
 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSIoTWirelessAsyncClient extends AWSIoTWirelessClient implements AWSIoTWirelessAsync {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

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

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

    /**
     * Constructs a new asynchronous client to invoke service methods on AWS IoT Wireless using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     * @param endpointDiscoveryEnabled
     *        true will enable endpoint discovery if the service supports it.
     */
    AWSIoTWirelessAsyncClient(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 associateAwsAccountWithPartnerAccountAsync(
            AssociateAwsAccountWithPartnerAccountRequest request) {

        return associateAwsAccountWithPartnerAccountAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future associateMulticastGroupWithFuotaTaskAsync(
            AssociateMulticastGroupWithFuotaTaskRequest request) {

        return associateMulticastGroupWithFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future associateWirelessDeviceWithFuotaTaskAsync(
            AssociateWirelessDeviceWithFuotaTaskRequest request) {

        return associateWirelessDeviceWithFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future associateWirelessDeviceWithMulticastGroupAsync(
            AssociateWirelessDeviceWithMulticastGroupRequest request) {

        return associateWirelessDeviceWithMulticastGroupAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future associateWirelessDeviceWithThingAsync(
            AssociateWirelessDeviceWithThingRequest request) {

        return associateWirelessDeviceWithThingAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future associateWirelessGatewayWithCertificateAsync(
            AssociateWirelessGatewayWithCertificateRequest request) {

        return associateWirelessGatewayWithCertificateAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future associateWirelessGatewayWithThingAsync(
            AssociateWirelessGatewayWithThingRequest request) {

        return associateWirelessGatewayWithThingAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future cancelMulticastGroupSessionAsync(CancelMulticastGroupSessionRequest request) {

        return cancelMulticastGroupSessionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createDestinationAsync(CreateDestinationRequest request) {

        return createDestinationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createDeviceProfileAsync(CreateDeviceProfileRequest request) {

        return createDeviceProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createFuotaTaskAsync(CreateFuotaTaskRequest request) {

        return createFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createMulticastGroupAsync(CreateMulticastGroupRequest request) {

        return createMulticastGroupAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createNetworkAnalyzerConfigurationAsync(
            CreateNetworkAnalyzerConfigurationRequest request) {

        return createNetworkAnalyzerConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createServiceProfileAsync(CreateServiceProfileRequest request) {

        return createServiceProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createWirelessDeviceAsync(CreateWirelessDeviceRequest request) {

        return createWirelessDeviceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createWirelessGatewayAsync(CreateWirelessGatewayRequest request) {

        return createWirelessGatewayAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createWirelessGatewayTaskAsync(CreateWirelessGatewayTaskRequest request) {

        return createWirelessGatewayTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createWirelessGatewayTaskDefinitionAsync(
            CreateWirelessGatewayTaskDefinitionRequest request) {

        return createWirelessGatewayTaskDefinitionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteDestinationAsync(DeleteDestinationRequest request) {

        return deleteDestinationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteDeviceProfileAsync(DeleteDeviceProfileRequest request) {

        return deleteDeviceProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteFuotaTaskAsync(DeleteFuotaTaskRequest request) {

        return deleteFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteMulticastGroupAsync(DeleteMulticastGroupRequest request) {

        return deleteMulticastGroupAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteNetworkAnalyzerConfigurationAsync(
            DeleteNetworkAnalyzerConfigurationRequest request) {

        return deleteNetworkAnalyzerConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteQueuedMessagesAsync(DeleteQueuedMessagesRequest request) {

        return deleteQueuedMessagesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteServiceProfileAsync(DeleteServiceProfileRequest request) {

        return deleteServiceProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteWirelessDeviceAsync(DeleteWirelessDeviceRequest request) {

        return deleteWirelessDeviceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteWirelessDeviceImportTaskAsync(DeleteWirelessDeviceImportTaskRequest request) {

        return deleteWirelessDeviceImportTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteWirelessGatewayAsync(DeleteWirelessGatewayRequest request) {

        return deleteWirelessGatewayAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteWirelessGatewayTaskAsync(DeleteWirelessGatewayTaskRequest request) {

        return deleteWirelessGatewayTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteWirelessGatewayTaskDefinitionAsync(
            DeleteWirelessGatewayTaskDefinitionRequest request) {

        return deleteWirelessGatewayTaskDefinitionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deregisterWirelessDeviceAsync(DeregisterWirelessDeviceRequest request) {

        return deregisterWirelessDeviceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateAwsAccountFromPartnerAccountAsync(
            DisassociateAwsAccountFromPartnerAccountRequest request) {

        return disassociateAwsAccountFromPartnerAccountAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateMulticastGroupFromFuotaTaskAsync(
            DisassociateMulticastGroupFromFuotaTaskRequest request) {

        return disassociateMulticastGroupFromFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateWirelessDeviceFromFuotaTaskAsync(
            DisassociateWirelessDeviceFromFuotaTaskRequest request) {

        return disassociateWirelessDeviceFromFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateWirelessDeviceFromMulticastGroupAsync(
            DisassociateWirelessDeviceFromMulticastGroupRequest request) {

        return disassociateWirelessDeviceFromMulticastGroupAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateWirelessDeviceFromThingAsync(
            DisassociateWirelessDeviceFromThingRequest request) {

        return disassociateWirelessDeviceFromThingAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateWirelessGatewayFromCertificateAsync(
            DisassociateWirelessGatewayFromCertificateRequest request) {

        return disassociateWirelessGatewayFromCertificateAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateWirelessGatewayFromThingAsync(
            DisassociateWirelessGatewayFromThingRequest request) {

        return disassociateWirelessGatewayFromThingAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getDestinationAsync(GetDestinationRequest request) {

        return getDestinationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getDeviceProfileAsync(GetDeviceProfileRequest request) {

        return getDeviceProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getEventConfigurationByResourceTypesAsync(
            GetEventConfigurationByResourceTypesRequest request) {

        return getEventConfigurationByResourceTypesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getFuotaTaskAsync(GetFuotaTaskRequest request) {

        return getFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getLogLevelsByResourceTypesAsync(GetLogLevelsByResourceTypesRequest request) {

        return getLogLevelsByResourceTypesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getMetricConfigurationAsync(GetMetricConfigurationRequest request) {

        return getMetricConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getMetricsAsync(GetMetricsRequest request) {

        return getMetricsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getMulticastGroupAsync(GetMulticastGroupRequest request) {

        return getMulticastGroupAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getMulticastGroupSessionAsync(GetMulticastGroupSessionRequest request) {

        return getMulticastGroupSessionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getNetworkAnalyzerConfigurationAsync(
            GetNetworkAnalyzerConfigurationRequest request) {

        return getNetworkAnalyzerConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getPartnerAccountAsync(GetPartnerAccountRequest request) {

        return getPartnerAccountAsync(request, null);
    }

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

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

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

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

    @Override
    @Deprecated
    public java.util.concurrent.Future getPositionAsync(GetPositionRequest request) {

        return getPositionAsync(request, null);
    }

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

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

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

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

    @Override
    @Deprecated
    public java.util.concurrent.Future getPositionConfigurationAsync(GetPositionConfigurationRequest request) {

        return getPositionConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getPositionEstimateAsync(GetPositionEstimateRequest request) {

        return getPositionEstimateAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getResourceEventConfigurationAsync(GetResourceEventConfigurationRequest request) {

        return getResourceEventConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getResourceLogLevelAsync(GetResourceLogLevelRequest request) {

        return getResourceLogLevelAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getResourcePositionAsync(GetResourcePositionRequest request) {

        return getResourcePositionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getServiceEndpointAsync(GetServiceEndpointRequest request) {

        return getServiceEndpointAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getServiceProfileAsync(GetServiceProfileRequest request) {

        return getServiceProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getWirelessDeviceAsync(GetWirelessDeviceRequest request) {

        return getWirelessDeviceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getWirelessDeviceImportTaskAsync(GetWirelessDeviceImportTaskRequest request) {

        return getWirelessDeviceImportTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getWirelessDeviceStatisticsAsync(GetWirelessDeviceStatisticsRequest request) {

        return getWirelessDeviceStatisticsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getWirelessGatewayAsync(GetWirelessGatewayRequest request) {

        return getWirelessGatewayAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getWirelessGatewayCertificateAsync(GetWirelessGatewayCertificateRequest request) {

        return getWirelessGatewayCertificateAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getWirelessGatewayFirmwareInformationAsync(
            GetWirelessGatewayFirmwareInformationRequest request) {

        return getWirelessGatewayFirmwareInformationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getWirelessGatewayStatisticsAsync(GetWirelessGatewayStatisticsRequest request) {

        return getWirelessGatewayStatisticsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getWirelessGatewayTaskAsync(GetWirelessGatewayTaskRequest request) {

        return getWirelessGatewayTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getWirelessGatewayTaskDefinitionAsync(
            GetWirelessGatewayTaskDefinitionRequest request) {

        return getWirelessGatewayTaskDefinitionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listDestinationsAsync(ListDestinationsRequest request) {

        return listDestinationsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listDeviceProfilesAsync(ListDeviceProfilesRequest request) {

        return listDeviceProfilesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listDevicesForWirelessDeviceImportTaskAsync(
            ListDevicesForWirelessDeviceImportTaskRequest request) {

        return listDevicesForWirelessDeviceImportTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listEventConfigurationsAsync(ListEventConfigurationsRequest request) {

        return listEventConfigurationsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listFuotaTasksAsync(ListFuotaTasksRequest request) {

        return listFuotaTasksAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listMulticastGroupsAsync(ListMulticastGroupsRequest request) {

        return listMulticastGroupsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listMulticastGroupsByFuotaTaskAsync(ListMulticastGroupsByFuotaTaskRequest request) {

        return listMulticastGroupsByFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listNetworkAnalyzerConfigurationsAsync(
            ListNetworkAnalyzerConfigurationsRequest request) {

        return listNetworkAnalyzerConfigurationsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listPartnerAccountsAsync(ListPartnerAccountsRequest request) {

        return listPartnerAccountsAsync(request, null);
    }

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

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

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

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

    @Override
    @Deprecated
    public java.util.concurrent.Future listPositionConfigurationsAsync(ListPositionConfigurationsRequest request) {

        return listPositionConfigurationsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listQueuedMessagesAsync(ListQueuedMessagesRequest request) {

        return listQueuedMessagesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listServiceProfilesAsync(ListServiceProfilesRequest request) {

        return listServiceProfilesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest request) {

        return listTagsForResourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listWirelessDeviceImportTasksAsync(ListWirelessDeviceImportTasksRequest request) {

        return listWirelessDeviceImportTasksAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listWirelessDevicesAsync(ListWirelessDevicesRequest request) {

        return listWirelessDevicesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listWirelessGatewayTaskDefinitionsAsync(
            ListWirelessGatewayTaskDefinitionsRequest request) {

        return listWirelessGatewayTaskDefinitionsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listWirelessGatewaysAsync(ListWirelessGatewaysRequest request) {

        return listWirelessGatewaysAsync(request, null);
    }

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

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

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

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

    @Override
    @Deprecated
    public java.util.concurrent.Future putPositionConfigurationAsync(PutPositionConfigurationRequest request) {

        return putPositionConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future putResourceLogLevelAsync(PutResourceLogLevelRequest request) {

        return putResourceLogLevelAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future resetAllResourceLogLevelsAsync(ResetAllResourceLogLevelsRequest request) {

        return resetAllResourceLogLevelsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future resetResourceLogLevelAsync(ResetResourceLogLevelRequest request) {

        return resetResourceLogLevelAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future sendDataToMulticastGroupAsync(SendDataToMulticastGroupRequest request) {

        return sendDataToMulticastGroupAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future sendDataToWirelessDeviceAsync(SendDataToWirelessDeviceRequest request) {

        return sendDataToWirelessDeviceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startBulkAssociateWirelessDeviceWithMulticastGroupAsync(
            StartBulkAssociateWirelessDeviceWithMulticastGroupRequest request) {

        return startBulkAssociateWirelessDeviceWithMulticastGroupAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startBulkDisassociateWirelessDeviceFromMulticastGroupAsync(
            StartBulkDisassociateWirelessDeviceFromMulticastGroupRequest request) {

        return startBulkDisassociateWirelessDeviceFromMulticastGroupAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startFuotaTaskAsync(StartFuotaTaskRequest request) {

        return startFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startMulticastGroupSessionAsync(StartMulticastGroupSessionRequest request) {

        return startMulticastGroupSessionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startSingleWirelessDeviceImportTaskAsync(
            StartSingleWirelessDeviceImportTaskRequest request) {

        return startSingleWirelessDeviceImportTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startWirelessDeviceImportTaskAsync(StartWirelessDeviceImportTaskRequest request) {

        return startWirelessDeviceImportTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future tagResourceAsync(TagResourceRequest request) {

        return tagResourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future testWirelessDeviceAsync(TestWirelessDeviceRequest request) {

        return testWirelessDeviceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future untagResourceAsync(UntagResourceRequest request) {

        return untagResourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateDestinationAsync(UpdateDestinationRequest request) {

        return updateDestinationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateEventConfigurationByResourceTypesAsync(
            UpdateEventConfigurationByResourceTypesRequest request) {

        return updateEventConfigurationByResourceTypesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateFuotaTaskAsync(UpdateFuotaTaskRequest request) {

        return updateFuotaTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateLogLevelsByResourceTypesAsync(UpdateLogLevelsByResourceTypesRequest request) {

        return updateLogLevelsByResourceTypesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateMetricConfigurationAsync(UpdateMetricConfigurationRequest request) {

        return updateMetricConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateMulticastGroupAsync(UpdateMulticastGroupRequest request) {

        return updateMulticastGroupAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateNetworkAnalyzerConfigurationAsync(
            UpdateNetworkAnalyzerConfigurationRequest request) {

        return updateNetworkAnalyzerConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updatePartnerAccountAsync(UpdatePartnerAccountRequest request) {

        return updatePartnerAccountAsync(request, null);
    }

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

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

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

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

    @Override
    @Deprecated
    public java.util.concurrent.Future updatePositionAsync(UpdatePositionRequest request) {

        return updatePositionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateResourceEventConfigurationAsync(
            UpdateResourceEventConfigurationRequest request) {

        return updateResourceEventConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateResourcePositionAsync(UpdateResourcePositionRequest request) {

        return updateResourcePositionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateWirelessDeviceAsync(UpdateWirelessDeviceRequest request) {

        return updateWirelessDeviceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateWirelessDeviceImportTaskAsync(UpdateWirelessDeviceImportTaskRequest request) {

        return updateWirelessDeviceImportTaskAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateWirelessGatewayAsync(UpdateWirelessGatewayRequest request) {

        return updateWirelessGatewayAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateWirelessGateway(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();
    }
}