• Home
• com.amazonaws
• aws-java-sdk-backup
• 1.12.777
• source code
• AWSBackupAsyncClient.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.backup.AWSBackupAsyncClient 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.backup;

import javax.annotation.Generated;

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

import java.util.concurrent.ExecutorService;

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

 * Backup
 * 

 * Backup is a unified backup service designed to protect Amazon Web Services services and their associated data. Backup
 * simplifies the creation, migration, restoration, and deletion of backups, while also providing reporting and
 * auditing.
 * 
 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSBackupAsyncClient extends AWSBackupClient implements AWSBackupAsync {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

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

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

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

        return cancelLegalHoldAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createBackupPlanAsync(CreateBackupPlanRequest request) {

        return createBackupPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createBackupSelectionAsync(CreateBackupSelectionRequest request) {

        return createBackupSelectionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createBackupVaultAsync(CreateBackupVaultRequest request) {

        return createBackupVaultAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createFrameworkAsync(CreateFrameworkRequest request) {

        return createFrameworkAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createLegalHoldAsync(CreateLegalHoldRequest request) {

        return createLegalHoldAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createLogicallyAirGappedBackupVaultAsync(
            CreateLogicallyAirGappedBackupVaultRequest request) {

        return createLogicallyAirGappedBackupVaultAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createReportPlanAsync(CreateReportPlanRequest request) {

        return createReportPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createRestoreTestingPlanAsync(CreateRestoreTestingPlanRequest request) {

        return createRestoreTestingPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future createRestoreTestingSelectionAsync(CreateRestoreTestingSelectionRequest request) {

        return createRestoreTestingSelectionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteBackupPlanAsync(DeleteBackupPlanRequest request) {

        return deleteBackupPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteBackupSelectionAsync(DeleteBackupSelectionRequest request) {

        return deleteBackupSelectionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteBackupVaultAsync(DeleteBackupVaultRequest request) {

        return deleteBackupVaultAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteBackupVaultAccessPolicyAsync(DeleteBackupVaultAccessPolicyRequest request) {

        return deleteBackupVaultAccessPolicyAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteBackupVaultLockConfigurationAsync(
            DeleteBackupVaultLockConfigurationRequest request) {

        return deleteBackupVaultLockConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteBackupVaultNotificationsAsync(DeleteBackupVaultNotificationsRequest request) {

        return deleteBackupVaultNotificationsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteFrameworkAsync(DeleteFrameworkRequest request) {

        return deleteFrameworkAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteRecoveryPointAsync(DeleteRecoveryPointRequest request) {

        return deleteRecoveryPointAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteReportPlanAsync(DeleteReportPlanRequest request) {

        return deleteReportPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteRestoreTestingPlanAsync(DeleteRestoreTestingPlanRequest request) {

        return deleteRestoreTestingPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future deleteRestoreTestingSelectionAsync(DeleteRestoreTestingSelectionRequest request) {

        return deleteRestoreTestingSelectionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeBackupJobAsync(DescribeBackupJobRequest request) {

        return describeBackupJobAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeBackupVaultAsync(DescribeBackupVaultRequest request) {

        return describeBackupVaultAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeCopyJobAsync(DescribeCopyJobRequest request) {

        return describeCopyJobAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeFrameworkAsync(DescribeFrameworkRequest request) {

        return describeFrameworkAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeGlobalSettingsAsync(DescribeGlobalSettingsRequest request) {

        return describeGlobalSettingsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeProtectedResourceAsync(DescribeProtectedResourceRequest request) {

        return describeProtectedResourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeRecoveryPointAsync(DescribeRecoveryPointRequest request) {

        return describeRecoveryPointAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeRegionSettingsAsync(DescribeRegionSettingsRequest request) {

        return describeRegionSettingsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeReportJobAsync(DescribeReportJobRequest request) {

        return describeReportJobAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeReportPlanAsync(DescribeReportPlanRequest request) {

        return describeReportPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future describeRestoreJobAsync(DescribeRestoreJobRequest request) {

        return describeRestoreJobAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateRecoveryPointAsync(DisassociateRecoveryPointRequest request) {

        return disassociateRecoveryPointAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future disassociateRecoveryPointFromParentAsync(
            DisassociateRecoveryPointFromParentRequest request) {

        return disassociateRecoveryPointFromParentAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future exportBackupPlanTemplateAsync(ExportBackupPlanTemplateRequest request) {

        return exportBackupPlanTemplateAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getBackupPlanAsync(GetBackupPlanRequest request) {

        return getBackupPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getBackupPlanFromJSONAsync(GetBackupPlanFromJSONRequest request) {

        return getBackupPlanFromJSONAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getBackupPlanFromTemplateAsync(GetBackupPlanFromTemplateRequest request) {

        return getBackupPlanFromTemplateAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getBackupSelectionAsync(GetBackupSelectionRequest request) {

        return getBackupSelectionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getBackupVaultAccessPolicyAsync(GetBackupVaultAccessPolicyRequest request) {

        return getBackupVaultAccessPolicyAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getBackupVaultNotificationsAsync(GetBackupVaultNotificationsRequest request) {

        return getBackupVaultNotificationsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getLegalHoldAsync(GetLegalHoldRequest request) {

        return getLegalHoldAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getRecoveryPointRestoreMetadataAsync(
            GetRecoveryPointRestoreMetadataRequest request) {

        return getRecoveryPointRestoreMetadataAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getRestoreJobMetadataAsync(GetRestoreJobMetadataRequest request) {

        return getRestoreJobMetadataAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getRestoreTestingInferredMetadataAsync(
            GetRestoreTestingInferredMetadataRequest request) {

        return getRestoreTestingInferredMetadataAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getRestoreTestingPlanAsync(GetRestoreTestingPlanRequest request) {

        return getRestoreTestingPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getRestoreTestingSelectionAsync(GetRestoreTestingSelectionRequest request) {

        return getRestoreTestingSelectionAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future getSupportedResourceTypesAsync(GetSupportedResourceTypesRequest request) {

        return getSupportedResourceTypesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listBackupJobSummariesAsync(ListBackupJobSummariesRequest request) {

        return listBackupJobSummariesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listBackupJobsAsync(ListBackupJobsRequest request) {

        return listBackupJobsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listBackupPlanTemplatesAsync(ListBackupPlanTemplatesRequest request) {

        return listBackupPlanTemplatesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listBackupPlanVersionsAsync(ListBackupPlanVersionsRequest request) {

        return listBackupPlanVersionsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listBackupPlansAsync(ListBackupPlansRequest request) {

        return listBackupPlansAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listBackupSelectionsAsync(ListBackupSelectionsRequest request) {

        return listBackupSelectionsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listBackupVaultsAsync(ListBackupVaultsRequest request) {

        return listBackupVaultsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listCopyJobSummariesAsync(ListCopyJobSummariesRequest request) {

        return listCopyJobSummariesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listCopyJobsAsync(ListCopyJobsRequest request) {

        return listCopyJobsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listFrameworksAsync(ListFrameworksRequest request) {

        return listFrameworksAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listLegalHoldsAsync(ListLegalHoldsRequest request) {

        return listLegalHoldsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listProtectedResourcesAsync(ListProtectedResourcesRequest request) {

        return listProtectedResourcesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listProtectedResourcesByBackupVaultAsync(
            ListProtectedResourcesByBackupVaultRequest request) {

        return listProtectedResourcesByBackupVaultAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listRecoveryPointsByBackupVaultAsync(
            ListRecoveryPointsByBackupVaultRequest request) {

        return listRecoveryPointsByBackupVaultAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listRecoveryPointsByLegalHoldAsync(ListRecoveryPointsByLegalHoldRequest request) {

        return listRecoveryPointsByLegalHoldAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listRecoveryPointsByResourceAsync(ListRecoveryPointsByResourceRequest request) {

        return listRecoveryPointsByResourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listReportJobsAsync(ListReportJobsRequest request) {

        return listReportJobsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listReportPlansAsync(ListReportPlansRequest request) {

        return listReportPlansAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listRestoreJobSummariesAsync(ListRestoreJobSummariesRequest request) {

        return listRestoreJobSummariesAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listRestoreJobsAsync(ListRestoreJobsRequest request) {

        return listRestoreJobsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listRestoreJobsByProtectedResourceAsync(
            ListRestoreJobsByProtectedResourceRequest request) {

        return listRestoreJobsByProtectedResourceAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listRestoreTestingPlansAsync(ListRestoreTestingPlansRequest request) {

        return listRestoreTestingPlansAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listRestoreTestingSelectionsAsync(ListRestoreTestingSelectionsRequest request) {

        return listRestoreTestingSelectionsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future listTagsAsync(ListTagsRequest request) {

        return listTagsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future putBackupVaultAccessPolicyAsync(PutBackupVaultAccessPolicyRequest request) {

        return putBackupVaultAccessPolicyAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future putBackupVaultLockConfigurationAsync(
            PutBackupVaultLockConfigurationRequest request) {

        return putBackupVaultLockConfigurationAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future putBackupVaultNotificationsAsync(PutBackupVaultNotificationsRequest request) {

        return putBackupVaultNotificationsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future putRestoreValidationResultAsync(PutRestoreValidationResultRequest request) {

        return putRestoreValidationResultAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startBackupJobAsync(StartBackupJobRequest request) {

        return startBackupJobAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startCopyJobAsync(StartCopyJobRequest request) {

        return startCopyJobAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startReportJobAsync(StartReportJobRequest request) {

        return startReportJobAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future startRestoreJobAsync(StartRestoreJobRequest request) {

        return startRestoreJobAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future stopBackupJobAsync(StopBackupJobRequest request) {

        return stopBackupJobAsync(request, null);
    }

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

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

                try {
                    result = executeStopBackupJob(finalRequest);
                } catch (Exception 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 updateBackupPlanAsync(UpdateBackupPlanRequest request) {

        return updateBackupPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateFrameworkAsync(UpdateFrameworkRequest request) {

        return updateFrameworkAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateGlobalSettingsAsync(UpdateGlobalSettingsRequest request) {

        return updateGlobalSettingsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateRecoveryPointLifecycleAsync(UpdateRecoveryPointLifecycleRequest request) {

        return updateRecoveryPointLifecycleAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateRegionSettingsAsync(UpdateRegionSettingsRequest request) {

        return updateRegionSettingsAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateReportPlanAsync(UpdateReportPlanRequest request) {

        return updateReportPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateRestoreTestingPlanAsync(UpdateRestoreTestingPlanRequest request) {

        return updateRestoreTestingPlanAsync(request, null);
    }

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

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

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

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

    @Override
    public java.util.concurrent.Future updateRestoreTestingSelectionAsync(UpdateRestoreTestingSelectionRequest request) {

        return updateRestoreTestingSelectionAsync(request, null);
    }

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

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

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