• Home
• com.amazonaws
• aws-java-sdk-datazoneexternal
• 1.12.780
• source code
• AmazonDataZoneAsyncClient.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.datazone.AmazonDataZoneAsyncClient 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.datazone;

import javax.annotation.Generated;

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

import java.util.concurrent.ExecutorService;

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

 * 

 * Amazon DataZone is a data management service that enables you to catalog, discover, govern, share, and analyze your
 * data. With Amazon DataZone, you can share and access your data across accounts and supported regions. Amazon DataZone
 * simplifies your experience across Amazon Web Services services, including, but not limited to, Amazon Redshift,
 * Amazon Athena, Amazon Web Services Glue, and Amazon Web Services Lake Formation.
 * 
 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonDataZoneAsyncClient extends AmazonDataZoneClient implements AmazonDataZoneAsync {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

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

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

    /**
     * Constructs a new asynchronous client to invoke service methods on Amazon DataZone using the specified parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     * @param endpointDiscoveryEnabled
     *        true will enable endpoint discovery if the service supports it.
     */
    AmazonDataZoneAsyncClient(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 acceptPredictionsAsync(AcceptPredictionsRequest request) {

        return acceptPredictionsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future acceptSubscriptionRequestAsync(AcceptSubscriptionRequestRequest request) {

        return acceptSubscriptionRequestAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future associateEnvironmentRoleAsync(AssociateEnvironmentRoleRequest request) {

        return associateEnvironmentRoleAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future cancelMetadataGenerationRunAsync(CancelMetadataGenerationRunRequest request) {

        return cancelMetadataGenerationRunAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future cancelSubscriptionAsync(CancelSubscriptionRequest request) {

        return cancelSubscriptionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createAssetAsync(CreateAssetRequest request) {

        return createAssetAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createAssetFilterAsync(CreateAssetFilterRequest request) {

        return createAssetFilterAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createAssetRevisionAsync(CreateAssetRevisionRequest request) {

        return createAssetRevisionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createAssetTypeAsync(CreateAssetTypeRequest request) {

        return createAssetTypeAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createDataSourceAsync(CreateDataSourceRequest request) {

        return createDataSourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createDomainAsync(CreateDomainRequest request) {

        return createDomainAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createEnvironmentAsync(CreateEnvironmentRequest request) {

        return createEnvironmentAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createEnvironmentActionAsync(CreateEnvironmentActionRequest request) {

        return createEnvironmentActionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createEnvironmentProfileAsync(CreateEnvironmentProfileRequest request) {

        return createEnvironmentProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createFormTypeAsync(CreateFormTypeRequest request) {

        return createFormTypeAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createGlossaryAsync(CreateGlossaryRequest request) {

        return createGlossaryAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createGlossaryTermAsync(CreateGlossaryTermRequest request) {

        return createGlossaryTermAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createGroupProfileAsync(CreateGroupProfileRequest request) {

        return createGroupProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createListingChangeSetAsync(CreateListingChangeSetRequest request) {

        return createListingChangeSetAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createProjectAsync(CreateProjectRequest request) {

        return createProjectAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createProjectMembershipAsync(CreateProjectMembershipRequest request) {

        return createProjectMembershipAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createSubscriptionGrantAsync(CreateSubscriptionGrantRequest request) {

        return createSubscriptionGrantAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createSubscriptionRequestAsync(CreateSubscriptionRequestRequest request) {

        return createSubscriptionRequestAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createSubscriptionTargetAsync(CreateSubscriptionTargetRequest request) {

        return createSubscriptionTargetAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createUserProfileAsync(CreateUserProfileRequest request) {

        return createUserProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteAssetAsync(DeleteAssetRequest request) {

        return deleteAssetAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteAssetFilterAsync(DeleteAssetFilterRequest request) {

        return deleteAssetFilterAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteAssetTypeAsync(DeleteAssetTypeRequest request) {

        return deleteAssetTypeAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteDataSourceAsync(DeleteDataSourceRequest request) {

        return deleteDataSourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteDomainAsync(DeleteDomainRequest request) {

        return deleteDomainAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteEnvironmentAsync(DeleteEnvironmentRequest request) {

        return deleteEnvironmentAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteEnvironmentActionAsync(DeleteEnvironmentActionRequest request) {

        return deleteEnvironmentActionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteEnvironmentBlueprintConfigurationAsync(
            DeleteEnvironmentBlueprintConfigurationRequest request) {

        return deleteEnvironmentBlueprintConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteEnvironmentProfileAsync(DeleteEnvironmentProfileRequest request) {

        return deleteEnvironmentProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteFormTypeAsync(DeleteFormTypeRequest request) {

        return deleteFormTypeAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteGlossaryAsync(DeleteGlossaryRequest request) {

        return deleteGlossaryAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteGlossaryTermAsync(DeleteGlossaryTermRequest request) {

        return deleteGlossaryTermAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteListingAsync(DeleteListingRequest request) {

        return deleteListingAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteProjectAsync(DeleteProjectRequest request) {

        return deleteProjectAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteProjectMembershipAsync(DeleteProjectMembershipRequest request) {

        return deleteProjectMembershipAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteSubscriptionGrantAsync(DeleteSubscriptionGrantRequest request) {

        return deleteSubscriptionGrantAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteSubscriptionRequestAsync(DeleteSubscriptionRequestRequest request) {

        return deleteSubscriptionRequestAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteSubscriptionTargetAsync(DeleteSubscriptionTargetRequest request) {

        return deleteSubscriptionTargetAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteTimeSeriesDataPointsAsync(DeleteTimeSeriesDataPointsRequest request) {

        return deleteTimeSeriesDataPointsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateEnvironmentRoleAsync(DisassociateEnvironmentRoleRequest request) {

        return disassociateEnvironmentRoleAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getAssetAsync(GetAssetRequest request) {

        return getAssetAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getAssetFilterAsync(GetAssetFilterRequest request) {

        return getAssetFilterAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getAssetTypeAsync(GetAssetTypeRequest request) {

        return getAssetTypeAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getDataSourceAsync(GetDataSourceRequest request) {

        return getDataSourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getDataSourceRunAsync(GetDataSourceRunRequest request) {

        return getDataSourceRunAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getDomainAsync(GetDomainRequest request) {

        return getDomainAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getEnvironmentAsync(GetEnvironmentRequest request) {

        return getEnvironmentAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getEnvironmentActionAsync(GetEnvironmentActionRequest request) {

        return getEnvironmentActionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getEnvironmentBlueprintAsync(GetEnvironmentBlueprintRequest request) {

        return getEnvironmentBlueprintAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getEnvironmentBlueprintConfigurationAsync(
            GetEnvironmentBlueprintConfigurationRequest request) {

        return getEnvironmentBlueprintConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getEnvironmentCredentialsAsync(GetEnvironmentCredentialsRequest request) {

        return getEnvironmentCredentialsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getEnvironmentProfileAsync(GetEnvironmentProfileRequest request) {

        return getEnvironmentProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getFormTypeAsync(GetFormTypeRequest request) {

        return getFormTypeAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getGlossaryAsync(GetGlossaryRequest request) {

        return getGlossaryAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getGlossaryTermAsync(GetGlossaryTermRequest request) {

        return getGlossaryTermAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getGroupProfileAsync(GetGroupProfileRequest request) {

        return getGroupProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getIamPortalLoginUrlAsync(GetIamPortalLoginUrlRequest request) {

        return getIamPortalLoginUrlAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getLineageNodeAsync(GetLineageNodeRequest request) {

        return getLineageNodeAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getListingAsync(GetListingRequest request) {

        return getListingAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getMetadataGenerationRunAsync(GetMetadataGenerationRunRequest request) {

        return getMetadataGenerationRunAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getProjectAsync(GetProjectRequest request) {

        return getProjectAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getSubscriptionAsync(GetSubscriptionRequest request) {

        return getSubscriptionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getSubscriptionGrantAsync(GetSubscriptionGrantRequest request) {

        return getSubscriptionGrantAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getSubscriptionRequestDetailsAsync(GetSubscriptionRequestDetailsRequest request) {

        return getSubscriptionRequestDetailsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getSubscriptionTargetAsync(GetSubscriptionTargetRequest request) {

        return getSubscriptionTargetAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getTimeSeriesDataPointAsync(GetTimeSeriesDataPointRequest request) {

        return getTimeSeriesDataPointAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getUserProfileAsync(GetUserProfileRequest request) {

        return getUserProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listAssetFiltersAsync(ListAssetFiltersRequest request) {

        return listAssetFiltersAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listAssetRevisionsAsync(ListAssetRevisionsRequest request) {

        return listAssetRevisionsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listDataSourceRunActivitiesAsync(ListDataSourceRunActivitiesRequest request) {

        return listDataSourceRunActivitiesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listDataSourceRunsAsync(ListDataSourceRunsRequest request) {

        return listDataSourceRunsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listDataSourcesAsync(ListDataSourcesRequest request) {

        return listDataSourcesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listDomainsAsync(ListDomainsRequest request) {

        return listDomainsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listEnvironmentActionsAsync(ListEnvironmentActionsRequest request) {

        return listEnvironmentActionsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listEnvironmentBlueprintConfigurationsAsync(
            ListEnvironmentBlueprintConfigurationsRequest request) {

        return listEnvironmentBlueprintConfigurationsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listEnvironmentBlueprintsAsync(ListEnvironmentBlueprintsRequest request) {

        return listEnvironmentBlueprintsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listEnvironmentProfilesAsync(ListEnvironmentProfilesRequest request) {

        return listEnvironmentProfilesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listEnvironmentsAsync(ListEnvironmentsRequest request) {

        return listEnvironmentsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listLineageNodeHistoryAsync(ListLineageNodeHistoryRequest request) {

        return listLineageNodeHistoryAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listMetadataGenerationRunsAsync(ListMetadataGenerationRunsRequest request) {

        return listMetadataGenerationRunsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listNotificationsAsync(ListNotificationsRequest request) {

        return listNotificationsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listProjectMembershipsAsync(ListProjectMembershipsRequest request) {

        return listProjectMembershipsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listProjectsAsync(ListProjectsRequest request) {

        return listProjectsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listSubscriptionGrantsAsync(ListSubscriptionGrantsRequest request) {

        return listSubscriptionGrantsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listSubscriptionRequestsAsync(ListSubscriptionRequestsRequest request) {

        return listSubscriptionRequestsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listSubscriptionTargetsAsync(ListSubscriptionTargetsRequest request) {

        return listSubscriptionTargetsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listSubscriptionsAsync(ListSubscriptionsRequest request) {

        return listSubscriptionsAsync(request, null);
    }

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

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

                try {
                    result = executeListSubscriptions(finalRequest);
                } catch (Exception 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 listTimeSeriesDataPointsAsync(ListTimeSeriesDataPointsRequest request) {

        return listTimeSeriesDataPointsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future postLineageEventAsync(PostLineageEventRequest request) {

        return postLineageEventAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future postTimeSeriesDataPointsAsync(PostTimeSeriesDataPointsRequest request) {

        return postTimeSeriesDataPointsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future putEnvironmentBlueprintConfigurationAsync(
            PutEnvironmentBlueprintConfigurationRequest request) {

        return putEnvironmentBlueprintConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future rejectPredictionsAsync(RejectPredictionsRequest request) {

        return rejectPredictionsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future rejectSubscriptionRequestAsync(RejectSubscriptionRequestRequest request) {

        return rejectSubscriptionRequestAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future revokeSubscriptionAsync(RevokeSubscriptionRequest request) {

        return revokeSubscriptionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future searchAsync(SearchRequest request) {

        return searchAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future searchGroupProfilesAsync(SearchGroupProfilesRequest request) {

        return searchGroupProfilesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future searchListingsAsync(SearchListingsRequest request) {

        return searchListingsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future searchTypesAsync(SearchTypesRequest request) {

        return searchTypesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future searchUserProfilesAsync(SearchUserProfilesRequest request) {

        return searchUserProfilesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startDataSourceRunAsync(StartDataSourceRunRequest request) {

        return startDataSourceRunAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startMetadataGenerationRunAsync(StartMetadataGenerationRunRequest request) {

        return startMetadataGenerationRunAsync(request, null);
    }

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

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

                try {
                    result = executeStartMetadataGenerationRun(finalRequest);
                } catch (Exception 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 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 updateAssetFilterAsync(UpdateAssetFilterRequest request) {

        return updateAssetFilterAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateDataSourceAsync(UpdateDataSourceRequest request) {

        return updateDataSourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateDomainAsync(UpdateDomainRequest request) {

        return updateDomainAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateEnvironmentAsync(UpdateEnvironmentRequest request) {

        return updateEnvironmentAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateEnvironmentActionAsync(UpdateEnvironmentActionRequest request) {

        return updateEnvironmentActionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateEnvironmentProfileAsync(UpdateEnvironmentProfileRequest request) {

        return updateEnvironmentProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateGlossaryAsync(UpdateGlossaryRequest request) {

        return updateGlossaryAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateGlossaryTermAsync(UpdateGlossaryTermRequest request) {

        return updateGlossaryTermAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateGroupProfileAsync(UpdateGroupProfileRequest request) {

        return updateGroupProfileAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateProjectAsync(UpdateProjectRequest request) {

        return updateProjectAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateSubscriptionGrantStatusAsync(UpdateSubscriptionGrantStatusRequest request) {

        return updateSubscriptionGrantStatusAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateSubscriptionRequestAsync(UpdateSubscriptionRequestRequest request) {

        return updateSubscriptionRequestAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateSubscriptionTargetAsync(UpdateSubscriptionTargetRequest request) {

        return updateSubscriptionTargetAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateUserProfileAsync(UpdateUserProfileRequest request) {

        return updateUserProfileAsync(request, null);
    }

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

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

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