• Home
• com.amazonaws
• aws-java-sdk-greengrass
• 1.11.378
• source code
• AWSGreengrassAsync.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.greengrass.AWSGreengrassAsync Maven / Gradle / Ivy

/*
 * Copyright 2013-2018 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.greengrass;

import javax.annotation.Generated;

import com.amazonaws.services.greengrass.model.*;

/**
 * Interface for accessing AWS Greengrass 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.
 * 

 * Note: Do not directly implement this interface, new methods are added to it regularly. Extend from
 * {@link com.amazonaws.services.greengrass.AbstractAWSGreengrassAsync} instead.
 * 
 * 

 * AWS Greengrass seamlessly extends AWS onto physical devices so they can act locally on the data they generate, while
 * still using the cloud for management, analytics, and durable storage. AWS Greengrass ensures your devices can respond
 * quickly to local events and operate with intermittent connectivity. AWS Greengrass minimizes the cost of transmitting
 * data to the cloud by allowing you to author AWS Lambda functions that execute locally.
 */
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public interface AWSGreengrassAsync extends AWSGreengrass {

    /**
     * Associates a role with a group. Your AWS Greengrass core will use the role to access AWS cloud services. The
     * role's permissions should allow Greengrass core Lambda functions to perform actions against the cloud.
     * 
     * @param associateRoleToGroupRequest
     * @return A Java Future containing the result of the AssociateRoleToGroup operation returned by the service.
     * @sample AWSGreengrassAsync.AssociateRoleToGroup
     * @see AWS API Documentation
     */
    java.util.concurrent.Future associateRoleToGroupAsync(AssociateRoleToGroupRequest associateRoleToGroupRequest);

    /**
     * Associates a role with a group. Your AWS Greengrass core will use the role to access AWS cloud services. The
     * role's permissions should allow Greengrass core Lambda functions to perform actions against the cloud.
     * 
     * @param associateRoleToGroupRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the AssociateRoleToGroup operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.AssociateRoleToGroup
     * @see AWS API Documentation
     */
    java.util.concurrent.Future associateRoleToGroupAsync(AssociateRoleToGroupRequest associateRoleToGroupRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Associates a role with your account. AWS Greengrass will use the role to access your Lambda functions and AWS IoT
     * resources. This is necessary for deployments to succeed. The role must have at least minimum permissions in the
     * policy ''AWSGreengrassResourceAccessRolePolicy''.
     * 
     * @param associateServiceRoleToAccountRequest
     * @return A Java Future containing the result of the AssociateServiceRoleToAccount operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.AssociateServiceRoleToAccount
     * @see AWS API Documentation
     */
    java.util.concurrent.Future associateServiceRoleToAccountAsync(
            AssociateServiceRoleToAccountRequest associateServiceRoleToAccountRequest);

    /**
     * Associates a role with your account. AWS Greengrass will use the role to access your Lambda functions and AWS IoT
     * resources. This is necessary for deployments to succeed. The role must have at least minimum permissions in the
     * policy ''AWSGreengrassResourceAccessRolePolicy''.
     * 
     * @param associateServiceRoleToAccountRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the AssociateServiceRoleToAccount operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.AssociateServiceRoleToAccount
     * @see AWS API Documentation
     */
    java.util.concurrent.Future associateServiceRoleToAccountAsync(
            AssociateServiceRoleToAccountRequest associateServiceRoleToAccountRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a core definition. You may provide the initial version of the core definition now or use
     * ''CreateCoreDefinitionVersion'' at a later time. AWS Greengrass groups must each contain exactly one AWS
     * Greengrass core.
     * 
     * @param createCoreDefinitionRequest
     *        Information needed to create a core definition.
     * @return A Java Future containing the result of the CreateCoreDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.CreateCoreDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createCoreDefinitionAsync(CreateCoreDefinitionRequest createCoreDefinitionRequest);

    /**
     * Creates a core definition. You may provide the initial version of the core definition now or use
     * ''CreateCoreDefinitionVersion'' at a later time. AWS Greengrass groups must each contain exactly one AWS
     * Greengrass core.
     * 
     * @param createCoreDefinitionRequest
     *        Information needed to create a core definition.
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateCoreDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateCoreDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createCoreDefinitionAsync(CreateCoreDefinitionRequest createCoreDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a version of a core definition that has already been defined. AWS Greengrass groups must each contain
     * exactly one AWS Greengrass core.
     * 
     * @param createCoreDefinitionVersionRequest
     * @return A Java Future containing the result of the CreateCoreDefinitionVersion operation returned by the service.
     * @sample AWSGreengrassAsync.CreateCoreDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createCoreDefinitionVersionAsync(
            CreateCoreDefinitionVersionRequest createCoreDefinitionVersionRequest);

    /**
     * Creates a version of a core definition that has already been defined. AWS Greengrass groups must each contain
     * exactly one AWS Greengrass core.
     * 
     * @param createCoreDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateCoreDefinitionVersion operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateCoreDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createCoreDefinitionVersionAsync(
            CreateCoreDefinitionVersionRequest createCoreDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a deployment.
     * 
     * @param createDeploymentRequest
     * @return A Java Future containing the result of the CreateDeployment operation returned by the service.
     * @sample AWSGreengrassAsync.CreateDeployment
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future createDeploymentAsync(CreateDeploymentRequest createDeploymentRequest);

    /**
     * Creates a deployment.
     * 
     * @param createDeploymentRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateDeployment operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateDeployment
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future createDeploymentAsync(CreateDeploymentRequest createDeploymentRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a device definition. You may provide the initial version of the device definition now or use
     * ''CreateDeviceDefinitionVersion'' at a later time.
     * 
     * @param createDeviceDefinitionRequest
     * @return A Java Future containing the result of the CreateDeviceDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.CreateDeviceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createDeviceDefinitionAsync(CreateDeviceDefinitionRequest createDeviceDefinitionRequest);

    /**
     * Creates a device definition. You may provide the initial version of the device definition now or use
     * ''CreateDeviceDefinitionVersion'' at a later time.
     * 
     * @param createDeviceDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateDeviceDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateDeviceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createDeviceDefinitionAsync(CreateDeviceDefinitionRequest createDeviceDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a version of a device definition that has already been defined.
     * 
     * @param createDeviceDefinitionVersionRequest
     * @return A Java Future containing the result of the CreateDeviceDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.CreateDeviceDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createDeviceDefinitionVersionAsync(
            CreateDeviceDefinitionVersionRequest createDeviceDefinitionVersionRequest);

    /**
     * Creates a version of a device definition that has already been defined.
     * 
     * @param createDeviceDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateDeviceDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.CreateDeviceDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createDeviceDefinitionVersionAsync(
            CreateDeviceDefinitionVersionRequest createDeviceDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a Lambda function definition which contains a list of Lambda functions and their configurations to be
     * used in a group. You can create an initial version of the definition by providing a list of Lambda functions and
     * their configurations now, or use ''CreateFunctionDefinitionVersion'' later.
     * 
     * @param createFunctionDefinitionRequest
     * @return A Java Future containing the result of the CreateFunctionDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.CreateFunctionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createFunctionDefinitionAsync(CreateFunctionDefinitionRequest createFunctionDefinitionRequest);

    /**
     * Creates a Lambda function definition which contains a list of Lambda functions and their configurations to be
     * used in a group. You can create an initial version of the definition by providing a list of Lambda functions and
     * their configurations now, or use ''CreateFunctionDefinitionVersion'' later.
     * 
     * @param createFunctionDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateFunctionDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateFunctionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createFunctionDefinitionAsync(CreateFunctionDefinitionRequest createFunctionDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a version of a Lambda function definition that has already been defined.
     * 
     * @param createFunctionDefinitionVersionRequest
     *        Information needed to create a function definition version.
     * @return A Java Future containing the result of the CreateFunctionDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.CreateFunctionDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createFunctionDefinitionVersionAsync(
            CreateFunctionDefinitionVersionRequest createFunctionDefinitionVersionRequest);

    /**
     * Creates a version of a Lambda function definition that has already been defined.
     * 
     * @param createFunctionDefinitionVersionRequest
     *        Information needed to create a function definition version.
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateFunctionDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.CreateFunctionDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createFunctionDefinitionVersionAsync(
            CreateFunctionDefinitionVersionRequest createFunctionDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a group. You may provide the initial version of the group or use ''CreateGroupVersion'' at a later time.
     * 
     * @param createGroupRequest
     * @return A Java Future containing the result of the CreateGroup operation returned by the service.
     * @sample AWSGreengrassAsync.CreateGroup
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future createGroupAsync(CreateGroupRequest createGroupRequest);

    /**
     * Creates a group. You may provide the initial version of the group or use ''CreateGroupVersion'' at a later time.
     * 
     * @param createGroupRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateGroup operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateGroup
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future createGroupAsync(CreateGroupRequest createGroupRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a CA for the group. If a CA already exists, it will rotate the existing CA.
     * 
     * @param createGroupCertificateAuthorityRequest
     * @return A Java Future containing the result of the CreateGroupCertificateAuthority operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.CreateGroupCertificateAuthority
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createGroupCertificateAuthorityAsync(
            CreateGroupCertificateAuthorityRequest createGroupCertificateAuthorityRequest);

    /**
     * Creates a CA for the group. If a CA already exists, it will rotate the existing CA.
     * 
     * @param createGroupCertificateAuthorityRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateGroupCertificateAuthority operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.CreateGroupCertificateAuthority
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createGroupCertificateAuthorityAsync(
            CreateGroupCertificateAuthorityRequest createGroupCertificateAuthorityRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a version of a group which has already been defined.
     * 
     * @param createGroupVersionRequest
     * @return A Java Future containing the result of the CreateGroupVersion operation returned by the service.
     * @sample AWSGreengrassAsync.CreateGroupVersion
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future createGroupVersionAsync(CreateGroupVersionRequest createGroupVersionRequest);

    /**
     * Creates a version of a group which has already been defined.
     * 
     * @param createGroupVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateGroupVersion operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateGroupVersion
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future createGroupVersionAsync(CreateGroupVersionRequest createGroupVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a logger definition. You may provide the initial version of the logger definition now or use
     * ''CreateLoggerDefinitionVersion'' at a later time.
     * 
     * @param createLoggerDefinitionRequest
     * @return A Java Future containing the result of the CreateLoggerDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.CreateLoggerDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createLoggerDefinitionAsync(CreateLoggerDefinitionRequest createLoggerDefinitionRequest);

    /**
     * Creates a logger definition. You may provide the initial version of the logger definition now or use
     * ''CreateLoggerDefinitionVersion'' at a later time.
     * 
     * @param createLoggerDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateLoggerDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateLoggerDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createLoggerDefinitionAsync(CreateLoggerDefinitionRequest createLoggerDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a version of a logger definition that has already been defined.
     * 
     * @param createLoggerDefinitionVersionRequest
     * @return A Java Future containing the result of the CreateLoggerDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.CreateLoggerDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createLoggerDefinitionVersionAsync(
            CreateLoggerDefinitionVersionRequest createLoggerDefinitionVersionRequest);

    /**
     * Creates a version of a logger definition that has already been defined.
     * 
     * @param createLoggerDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateLoggerDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.CreateLoggerDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createLoggerDefinitionVersionAsync(
            CreateLoggerDefinitionVersionRequest createLoggerDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a resource definition which contains a list of resources to be used in a group. You can create an initial
     * version of the definition by providing a list of resources now, or use ''CreateResourceDefinitionVersion'' later.
     * 
     * @param createResourceDefinitionRequest
     * @return A Java Future containing the result of the CreateResourceDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.CreateResourceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createResourceDefinitionAsync(CreateResourceDefinitionRequest createResourceDefinitionRequest);

    /**
     * Creates a resource definition which contains a list of resources to be used in a group. You can create an initial
     * version of the definition by providing a list of resources now, or use ''CreateResourceDefinitionVersion'' later.
     * 
     * @param createResourceDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateResourceDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateResourceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createResourceDefinitionAsync(CreateResourceDefinitionRequest createResourceDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a version of a resource definition that has already been defined.
     * 
     * @param createResourceDefinitionVersionRequest
     * @return A Java Future containing the result of the CreateResourceDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.CreateResourceDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createResourceDefinitionVersionAsync(
            CreateResourceDefinitionVersionRequest createResourceDefinitionVersionRequest);

    /**
     * Creates a version of a resource definition that has already been defined.
     * 
     * @param createResourceDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateResourceDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.CreateResourceDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createResourceDefinitionVersionAsync(
            CreateResourceDefinitionVersionRequest createResourceDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a software update for a core or group of cores (specified as an IoT thing group.) Use this to update the
     * OTA Agent as well as the Greengrass core software. It makes use of the IoT Jobs feature which provides additional
     * commands to manage a Greengrass core software update job.
     * 
     * @param createSoftwareUpdateJobRequest
     * @return A Java Future containing the result of the CreateSoftwareUpdateJob operation returned by the service.
     * @sample AWSGreengrassAsync.CreateSoftwareUpdateJob
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createSoftwareUpdateJobAsync(CreateSoftwareUpdateJobRequest createSoftwareUpdateJobRequest);

    /**
     * Creates a software update for a core or group of cores (specified as an IoT thing group.) Use this to update the
     * OTA Agent as well as the Greengrass core software. It makes use of the IoT Jobs feature which provides additional
     * commands to manage a Greengrass core software update job.
     * 
     * @param createSoftwareUpdateJobRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateSoftwareUpdateJob operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.CreateSoftwareUpdateJob
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createSoftwareUpdateJobAsync(CreateSoftwareUpdateJobRequest createSoftwareUpdateJobRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a subscription definition. You may provide the initial version of the subscription definition now or use
     * ''CreateSubscriptionDefinitionVersion'' at a later time.
     * 
     * @param createSubscriptionDefinitionRequest
     * @return A Java Future containing the result of the CreateSubscriptionDefinition operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.CreateSubscriptionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createSubscriptionDefinitionAsync(
            CreateSubscriptionDefinitionRequest createSubscriptionDefinitionRequest);

    /**
     * Creates a subscription definition. You may provide the initial version of the subscription definition now or use
     * ''CreateSubscriptionDefinitionVersion'' at a later time.
     * 
     * @param createSubscriptionDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateSubscriptionDefinition operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.CreateSubscriptionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createSubscriptionDefinitionAsync(
            CreateSubscriptionDefinitionRequest createSubscriptionDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Creates a version of a subscription definition which has already been defined.
     * 
     * @param createSubscriptionDefinitionVersionRequest
     * @return A Java Future containing the result of the CreateSubscriptionDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.CreateSubscriptionDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createSubscriptionDefinitionVersionAsync(
            CreateSubscriptionDefinitionVersionRequest createSubscriptionDefinitionVersionRequest);

    /**
     * Creates a version of a subscription definition which has already been defined.
     * 
     * @param createSubscriptionDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the CreateSubscriptionDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.CreateSubscriptionDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future createSubscriptionDefinitionVersionAsync(
            CreateSubscriptionDefinitionVersionRequest createSubscriptionDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Deletes a core definition.
     * 
     * @param deleteCoreDefinitionRequest
     * @return A Java Future containing the result of the DeleteCoreDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.DeleteCoreDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteCoreDefinitionAsync(DeleteCoreDefinitionRequest deleteCoreDefinitionRequest);

    /**
     * Deletes a core definition.
     * 
     * @param deleteCoreDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DeleteCoreDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.DeleteCoreDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteCoreDefinitionAsync(DeleteCoreDefinitionRequest deleteCoreDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Deletes a device definition.
     * 
     * @param deleteDeviceDefinitionRequest
     * @return A Java Future containing the result of the DeleteDeviceDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.DeleteDeviceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteDeviceDefinitionAsync(DeleteDeviceDefinitionRequest deleteDeviceDefinitionRequest);

    /**
     * Deletes a device definition.
     * 
     * @param deleteDeviceDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DeleteDeviceDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.DeleteDeviceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteDeviceDefinitionAsync(DeleteDeviceDefinitionRequest deleteDeviceDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Deletes a Lambda function definition.
     * 
     * @param deleteFunctionDefinitionRequest
     * @return A Java Future containing the result of the DeleteFunctionDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.DeleteFunctionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteFunctionDefinitionAsync(DeleteFunctionDefinitionRequest deleteFunctionDefinitionRequest);

    /**
     * Deletes a Lambda function definition.
     * 
     * @param deleteFunctionDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DeleteFunctionDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.DeleteFunctionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteFunctionDefinitionAsync(DeleteFunctionDefinitionRequest deleteFunctionDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Deletes a group.
     * 
     * @param deleteGroupRequest
     * @return A Java Future containing the result of the DeleteGroup operation returned by the service.
     * @sample AWSGreengrassAsync.DeleteGroup
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future deleteGroupAsync(DeleteGroupRequest deleteGroupRequest);

    /**
     * Deletes a group.
     * 
     * @param deleteGroupRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DeleteGroup operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.DeleteGroup
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future deleteGroupAsync(DeleteGroupRequest deleteGroupRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Deletes a logger definition.
     * 
     * @param deleteLoggerDefinitionRequest
     * @return A Java Future containing the result of the DeleteLoggerDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.DeleteLoggerDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteLoggerDefinitionAsync(DeleteLoggerDefinitionRequest deleteLoggerDefinitionRequest);

    /**
     * Deletes a logger definition.
     * 
     * @param deleteLoggerDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DeleteLoggerDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.DeleteLoggerDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteLoggerDefinitionAsync(DeleteLoggerDefinitionRequest deleteLoggerDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Deletes a resource definition.
     * 
     * @param deleteResourceDefinitionRequest
     * @return A Java Future containing the result of the DeleteResourceDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.DeleteResourceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteResourceDefinitionAsync(DeleteResourceDefinitionRequest deleteResourceDefinitionRequest);

    /**
     * Deletes a resource definition.
     * 
     * @param deleteResourceDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DeleteResourceDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.DeleteResourceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteResourceDefinitionAsync(DeleteResourceDefinitionRequest deleteResourceDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Deletes a subscription definition.
     * 
     * @param deleteSubscriptionDefinitionRequest
     * @return A Java Future containing the result of the DeleteSubscriptionDefinition operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.DeleteSubscriptionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteSubscriptionDefinitionAsync(
            DeleteSubscriptionDefinitionRequest deleteSubscriptionDefinitionRequest);

    /**
     * Deletes a subscription definition.
     * 
     * @param deleteSubscriptionDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DeleteSubscriptionDefinition operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.DeleteSubscriptionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future deleteSubscriptionDefinitionAsync(
            DeleteSubscriptionDefinitionRequest deleteSubscriptionDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Disassociates the role from a group.
     * 
     * @param disassociateRoleFromGroupRequest
     * @return A Java Future containing the result of the DisassociateRoleFromGroup operation returned by the service.
     * @sample AWSGreengrassAsync.DisassociateRoleFromGroup
     * @see AWS API Documentation
     */
    java.util.concurrent.Future disassociateRoleFromGroupAsync(
            DisassociateRoleFromGroupRequest disassociateRoleFromGroupRequest);

    /**
     * Disassociates the role from a group.
     * 
     * @param disassociateRoleFromGroupRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DisassociateRoleFromGroup operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.DisassociateRoleFromGroup
     * @see AWS API Documentation
     */
    java.util.concurrent.Future disassociateRoleFromGroupAsync(
            DisassociateRoleFromGroupRequest disassociateRoleFromGroupRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Disassociates the service role from your account. Without a service role, deployments will not work.
     * 
     * @param disassociateServiceRoleFromAccountRequest
     * @return A Java Future containing the result of the DisassociateServiceRoleFromAccount operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.DisassociateServiceRoleFromAccount
     * @see AWS API Documentation
     */
    java.util.concurrent.Future disassociateServiceRoleFromAccountAsync(
            DisassociateServiceRoleFromAccountRequest disassociateServiceRoleFromAccountRequest);

    /**
     * Disassociates the service role from your account. Without a service role, deployments will not work.
     * 
     * @param disassociateServiceRoleFromAccountRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the DisassociateServiceRoleFromAccount operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.DisassociateServiceRoleFromAccount
     * @see AWS API Documentation
     */
    java.util.concurrent.Future disassociateServiceRoleFromAccountAsync(
            DisassociateServiceRoleFromAccountRequest disassociateServiceRoleFromAccountRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves the role associated with a particular group.
     * 
     * @param getAssociatedRoleRequest
     * @return A Java Future containing the result of the GetAssociatedRole operation returned by the service.
     * @sample AWSGreengrassAsync.GetAssociatedRole
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getAssociatedRoleAsync(GetAssociatedRoleRequest getAssociatedRoleRequest);

    /**
     * Retrieves the role associated with a particular group.
     * 
     * @param getAssociatedRoleRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetAssociatedRole operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetAssociatedRole
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getAssociatedRoleAsync(GetAssociatedRoleRequest getAssociatedRoleRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves the connectivity information for a core.
     * 
     * @param getConnectivityInfoRequest
     * @return A Java Future containing the result of the GetConnectivityInfo operation returned by the service.
     * @sample AWSGreengrassAsync.GetConnectivityInfo
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getConnectivityInfoAsync(GetConnectivityInfoRequest getConnectivityInfoRequest);

    /**
     * Retrieves the connectivity information for a core.
     * 
     * @param getConnectivityInfoRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetConnectivityInfo operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetConnectivityInfo
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getConnectivityInfoAsync(GetConnectivityInfoRequest getConnectivityInfoRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a core definition version.
     * 
     * @param getCoreDefinitionRequest
     * @return A Java Future containing the result of the GetCoreDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.GetCoreDefinition
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getCoreDefinitionAsync(GetCoreDefinitionRequest getCoreDefinitionRequest);

    /**
     * Retrieves information about a core definition version.
     * 
     * @param getCoreDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetCoreDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetCoreDefinition
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getCoreDefinitionAsync(GetCoreDefinitionRequest getCoreDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a core definition version.
     * 
     * @param getCoreDefinitionVersionRequest
     * @return A Java Future containing the result of the GetCoreDefinitionVersion operation returned by the service.
     * @sample AWSGreengrassAsync.GetCoreDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getCoreDefinitionVersionAsync(GetCoreDefinitionVersionRequest getCoreDefinitionVersionRequest);

    /**
     * Retrieves information about a core definition version.
     * 
     * @param getCoreDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetCoreDefinitionVersion operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetCoreDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getCoreDefinitionVersionAsync(GetCoreDefinitionVersionRequest getCoreDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Returns the status of a deployment.
     * 
     * @param getDeploymentStatusRequest
     * @return A Java Future containing the result of the GetDeploymentStatus operation returned by the service.
     * @sample AWSGreengrassAsync.GetDeploymentStatus
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getDeploymentStatusAsync(GetDeploymentStatusRequest getDeploymentStatusRequest);

    /**
     * Returns the status of a deployment.
     * 
     * @param getDeploymentStatusRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetDeploymentStatus operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetDeploymentStatus
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getDeploymentStatusAsync(GetDeploymentStatusRequest getDeploymentStatusRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a device definition.
     * 
     * @param getDeviceDefinitionRequest
     * @return A Java Future containing the result of the GetDeviceDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.GetDeviceDefinition
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getDeviceDefinitionAsync(GetDeviceDefinitionRequest getDeviceDefinitionRequest);

    /**
     * Retrieves information about a device definition.
     * 
     * @param getDeviceDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetDeviceDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetDeviceDefinition
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getDeviceDefinitionAsync(GetDeviceDefinitionRequest getDeviceDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a device definition version.
     * 
     * @param getDeviceDefinitionVersionRequest
     * @return A Java Future containing the result of the GetDeviceDefinitionVersion operation returned by the service.
     * @sample AWSGreengrassAsync.GetDeviceDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getDeviceDefinitionVersionAsync(
            GetDeviceDefinitionVersionRequest getDeviceDefinitionVersionRequest);

    /**
     * Retrieves information about a device definition version.
     * 
     * @param getDeviceDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetDeviceDefinitionVersion operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetDeviceDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getDeviceDefinitionVersionAsync(
            GetDeviceDefinitionVersionRequest getDeviceDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a Lambda function definition, including its creation time and latest version.
     * 
     * @param getFunctionDefinitionRequest
     * @return A Java Future containing the result of the GetFunctionDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.GetFunctionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getFunctionDefinitionAsync(GetFunctionDefinitionRequest getFunctionDefinitionRequest);

    /**
     * Retrieves information about a Lambda function definition, including its creation time and latest version.
     * 
     * @param getFunctionDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetFunctionDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetFunctionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getFunctionDefinitionAsync(GetFunctionDefinitionRequest getFunctionDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a Lambda function definition version, including which Lambda functions are included
     * in the version and their configurations.
     * 
     * @param getFunctionDefinitionVersionRequest
     * @return A Java Future containing the result of the GetFunctionDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.GetFunctionDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getFunctionDefinitionVersionAsync(
            GetFunctionDefinitionVersionRequest getFunctionDefinitionVersionRequest);

    /**
     * Retrieves information about a Lambda function definition version, including which Lambda functions are included
     * in the version and their configurations.
     * 
     * @param getFunctionDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetFunctionDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.GetFunctionDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getFunctionDefinitionVersionAsync(
            GetFunctionDefinitionVersionRequest getFunctionDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a group.
     * 
     * @param getGroupRequest
     * @return A Java Future containing the result of the GetGroup operation returned by the service.
     * @sample AWSGreengrassAsync.GetGroup
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future getGroupAsync(GetGroupRequest getGroupRequest);

    /**
     * Retrieves information about a group.
     * 
     * @param getGroupRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetGroup operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetGroup
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future getGroupAsync(GetGroupRequest getGroupRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retreives the CA associated with a group. Returns the public key of the CA.
     * 
     * @param getGroupCertificateAuthorityRequest
     * @return A Java Future containing the result of the GetGroupCertificateAuthority operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.GetGroupCertificateAuthority
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getGroupCertificateAuthorityAsync(
            GetGroupCertificateAuthorityRequest getGroupCertificateAuthorityRequest);

    /**
     * Retreives the CA associated with a group. Returns the public key of the CA.
     * 
     * @param getGroupCertificateAuthorityRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetGroupCertificateAuthority operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.GetGroupCertificateAuthority
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getGroupCertificateAuthorityAsync(
            GetGroupCertificateAuthorityRequest getGroupCertificateAuthorityRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves the current configuration for the CA used by the group.
     * 
     * @param getGroupCertificateConfigurationRequest
     * @return A Java Future containing the result of the GetGroupCertificateConfiguration operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.GetGroupCertificateConfiguration
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getGroupCertificateConfigurationAsync(
            GetGroupCertificateConfigurationRequest getGroupCertificateConfigurationRequest);

    /**
     * Retrieves the current configuration for the CA used by the group.
     * 
     * @param getGroupCertificateConfigurationRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetGroupCertificateConfiguration operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.GetGroupCertificateConfiguration
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getGroupCertificateConfigurationAsync(
            GetGroupCertificateConfigurationRequest getGroupCertificateConfigurationRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a group version.
     * 
     * @param getGroupVersionRequest
     * @return A Java Future containing the result of the GetGroupVersion operation returned by the service.
     * @sample AWSGreengrassAsync.GetGroupVersion
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future getGroupVersionAsync(GetGroupVersionRequest getGroupVersionRequest);

    /**
     * Retrieves information about a group version.
     * 
     * @param getGroupVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetGroupVersion operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetGroupVersion
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future getGroupVersionAsync(GetGroupVersionRequest getGroupVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a logger definition.
     * 
     * @param getLoggerDefinitionRequest
     * @return A Java Future containing the result of the GetLoggerDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.GetLoggerDefinition
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getLoggerDefinitionAsync(GetLoggerDefinitionRequest getLoggerDefinitionRequest);

    /**
     * Retrieves information about a logger definition.
     * 
     * @param getLoggerDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetLoggerDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetLoggerDefinition
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future getLoggerDefinitionAsync(GetLoggerDefinitionRequest getLoggerDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a logger definition version.
     * 
     * @param getLoggerDefinitionVersionRequest
     * @return A Java Future containing the result of the GetLoggerDefinitionVersion operation returned by the service.
     * @sample AWSGreengrassAsync.GetLoggerDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getLoggerDefinitionVersionAsync(
            GetLoggerDefinitionVersionRequest getLoggerDefinitionVersionRequest);

    /**
     * Retrieves information about a logger definition version.
     * 
     * @param getLoggerDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetLoggerDefinitionVersion operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetLoggerDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getLoggerDefinitionVersionAsync(
            GetLoggerDefinitionVersionRequest getLoggerDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a resource definition, including its creation time and latest version.
     * 
     * @param getResourceDefinitionRequest
     * @return A Java Future containing the result of the GetResourceDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.GetResourceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getResourceDefinitionAsync(GetResourceDefinitionRequest getResourceDefinitionRequest);

    /**
     * Retrieves information about a resource definition, including its creation time and latest version.
     * 
     * @param getResourceDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetResourceDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetResourceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getResourceDefinitionAsync(GetResourceDefinitionRequest getResourceDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a resource definition version, including which resources are included in the version.
     * 
     * @param getResourceDefinitionVersionRequest
     * @return A Java Future containing the result of the GetResourceDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.GetResourceDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getResourceDefinitionVersionAsync(
            GetResourceDefinitionVersionRequest getResourceDefinitionVersionRequest);

    /**
     * Retrieves information about a resource definition version, including which resources are included in the version.
     * 
     * @param getResourceDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetResourceDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.GetResourceDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getResourceDefinitionVersionAsync(
            GetResourceDefinitionVersionRequest getResourceDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves the service role that is attached to your account.
     * 
     * @param getServiceRoleForAccountRequest
     * @return A Java Future containing the result of the GetServiceRoleForAccount operation returned by the service.
     * @sample AWSGreengrassAsync.GetServiceRoleForAccount
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getServiceRoleForAccountAsync(GetServiceRoleForAccountRequest getServiceRoleForAccountRequest);

    /**
     * Retrieves the service role that is attached to your account.
     * 
     * @param getServiceRoleForAccountRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetServiceRoleForAccount operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetServiceRoleForAccount
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getServiceRoleForAccountAsync(GetServiceRoleForAccountRequest getServiceRoleForAccountRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a subscription definition.
     * 
     * @param getSubscriptionDefinitionRequest
     * @return A Java Future containing the result of the GetSubscriptionDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.GetSubscriptionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getSubscriptionDefinitionAsync(
            GetSubscriptionDefinitionRequest getSubscriptionDefinitionRequest);

    /**
     * Retrieves information about a subscription definition.
     * 
     * @param getSubscriptionDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetSubscriptionDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.GetSubscriptionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getSubscriptionDefinitionAsync(
            GetSubscriptionDefinitionRequest getSubscriptionDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves information about a subscription definition version.
     * 
     * @param getSubscriptionDefinitionVersionRequest
     * @return A Java Future containing the result of the GetSubscriptionDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.GetSubscriptionDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getSubscriptionDefinitionVersionAsync(
            GetSubscriptionDefinitionVersionRequest getSubscriptionDefinitionVersionRequest);

    /**
     * Retrieves information about a subscription definition version.
     * 
     * @param getSubscriptionDefinitionVersionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the GetSubscriptionDefinitionVersion operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.GetSubscriptionDefinitionVersion
     * @see AWS API Documentation
     */
    java.util.concurrent.Future getSubscriptionDefinitionVersionAsync(
            GetSubscriptionDefinitionVersionRequest getSubscriptionDefinitionVersionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Lists the versions of a core definition.
     * 
     * @param listCoreDefinitionVersionsRequest
     * @return A Java Future containing the result of the ListCoreDefinitionVersions operation returned by the service.
     * @sample AWSGreengrassAsync.ListCoreDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listCoreDefinitionVersionsAsync(
            ListCoreDefinitionVersionsRequest listCoreDefinitionVersionsRequest);

    /**
     * Lists the versions of a core definition.
     * 
     * @param listCoreDefinitionVersionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListCoreDefinitionVersions operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListCoreDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listCoreDefinitionVersionsAsync(
            ListCoreDefinitionVersionsRequest listCoreDefinitionVersionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves a list of core definitions.
     * 
     * @param listCoreDefinitionsRequest
     * @return A Java Future containing the result of the ListCoreDefinitions operation returned by the service.
     * @sample AWSGreengrassAsync.ListCoreDefinitions
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future listCoreDefinitionsAsync(ListCoreDefinitionsRequest listCoreDefinitionsRequest);

    /**
     * Retrieves a list of core definitions.
     * 
     * @param listCoreDefinitionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListCoreDefinitions operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListCoreDefinitions
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future listCoreDefinitionsAsync(ListCoreDefinitionsRequest listCoreDefinitionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Returns a history of deployments for the group.
     * 
     * @param listDeploymentsRequest
     * @return A Java Future containing the result of the ListDeployments operation returned by the service.
     * @sample AWSGreengrassAsync.ListDeployments
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future listDeploymentsAsync(ListDeploymentsRequest listDeploymentsRequest);

    /**
     * Returns a history of deployments for the group.
     * 
     * @param listDeploymentsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListDeployments operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListDeployments
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future listDeploymentsAsync(ListDeploymentsRequest listDeploymentsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Lists the versions of a device definition.
     * 
     * @param listDeviceDefinitionVersionsRequest
     * @return A Java Future containing the result of the ListDeviceDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.ListDeviceDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listDeviceDefinitionVersionsAsync(
            ListDeviceDefinitionVersionsRequest listDeviceDefinitionVersionsRequest);

    /**
     * Lists the versions of a device definition.
     * 
     * @param listDeviceDefinitionVersionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListDeviceDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.ListDeviceDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listDeviceDefinitionVersionsAsync(
            ListDeviceDefinitionVersionsRequest listDeviceDefinitionVersionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves a list of device definitions.
     * 
     * @param listDeviceDefinitionsRequest
     * @return A Java Future containing the result of the ListDeviceDefinitions operation returned by the service.
     * @sample AWSGreengrassAsync.ListDeviceDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listDeviceDefinitionsAsync(ListDeviceDefinitionsRequest listDeviceDefinitionsRequest);

    /**
     * Retrieves a list of device definitions.
     * 
     * @param listDeviceDefinitionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListDeviceDefinitions operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListDeviceDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listDeviceDefinitionsAsync(ListDeviceDefinitionsRequest listDeviceDefinitionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Lists the versions of a Lambda function definition.
     * 
     * @param listFunctionDefinitionVersionsRequest
     * @return A Java Future containing the result of the ListFunctionDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.ListFunctionDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listFunctionDefinitionVersionsAsync(
            ListFunctionDefinitionVersionsRequest listFunctionDefinitionVersionsRequest);

    /**
     * Lists the versions of a Lambda function definition.
     * 
     * @param listFunctionDefinitionVersionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListFunctionDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.ListFunctionDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listFunctionDefinitionVersionsAsync(
            ListFunctionDefinitionVersionsRequest listFunctionDefinitionVersionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves a list of Lambda function definitions.
     * 
     * @param listFunctionDefinitionsRequest
     * @return A Java Future containing the result of the ListFunctionDefinitions operation returned by the service.
     * @sample AWSGreengrassAsync.ListFunctionDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listFunctionDefinitionsAsync(ListFunctionDefinitionsRequest listFunctionDefinitionsRequest);

    /**
     * Retrieves a list of Lambda function definitions.
     * 
     * @param listFunctionDefinitionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListFunctionDefinitions operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListFunctionDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listFunctionDefinitionsAsync(ListFunctionDefinitionsRequest listFunctionDefinitionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves the current CAs for a group.
     * 
     * @param listGroupCertificateAuthoritiesRequest
     * @return A Java Future containing the result of the ListGroupCertificateAuthorities operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.ListGroupCertificateAuthorities
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listGroupCertificateAuthoritiesAsync(
            ListGroupCertificateAuthoritiesRequest listGroupCertificateAuthoritiesRequest);

    /**
     * Retrieves the current CAs for a group.
     * 
     * @param listGroupCertificateAuthoritiesRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListGroupCertificateAuthorities operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.ListGroupCertificateAuthorities
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listGroupCertificateAuthoritiesAsync(
            ListGroupCertificateAuthoritiesRequest listGroupCertificateAuthoritiesRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Lists the versions of a group.
     * 
     * @param listGroupVersionsRequest
     * @return A Java Future containing the result of the ListGroupVersions operation returned by the service.
     * @sample AWSGreengrassAsync.ListGroupVersions
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future listGroupVersionsAsync(ListGroupVersionsRequest listGroupVersionsRequest);

    /**
     * Lists the versions of a group.
     * 
     * @param listGroupVersionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListGroupVersions operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListGroupVersions
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future listGroupVersionsAsync(ListGroupVersionsRequest listGroupVersionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves a list of groups.
     * 
     * @param listGroupsRequest
     * @return A Java Future containing the result of the ListGroups operation returned by the service.
     * @sample AWSGreengrassAsync.ListGroups
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future listGroupsAsync(ListGroupsRequest listGroupsRequest);

    /**
     * Retrieves a list of groups.
     * 
     * @param listGroupsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListGroups operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListGroups
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future listGroupsAsync(ListGroupsRequest listGroupsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Lists the versions of a logger definition.
     * 
     * @param listLoggerDefinitionVersionsRequest
     * @return A Java Future containing the result of the ListLoggerDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.ListLoggerDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listLoggerDefinitionVersionsAsync(
            ListLoggerDefinitionVersionsRequest listLoggerDefinitionVersionsRequest);

    /**
     * Lists the versions of a logger definition.
     * 
     * @param listLoggerDefinitionVersionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListLoggerDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.ListLoggerDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listLoggerDefinitionVersionsAsync(
            ListLoggerDefinitionVersionsRequest listLoggerDefinitionVersionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves a list of logger definitions.
     * 
     * @param listLoggerDefinitionsRequest
     * @return A Java Future containing the result of the ListLoggerDefinitions operation returned by the service.
     * @sample AWSGreengrassAsync.ListLoggerDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listLoggerDefinitionsAsync(ListLoggerDefinitionsRequest listLoggerDefinitionsRequest);

    /**
     * Retrieves a list of logger definitions.
     * 
     * @param listLoggerDefinitionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListLoggerDefinitions operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListLoggerDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listLoggerDefinitionsAsync(ListLoggerDefinitionsRequest listLoggerDefinitionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Lists the versions of a resource definition.
     * 
     * @param listResourceDefinitionVersionsRequest
     * @return A Java Future containing the result of the ListResourceDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.ListResourceDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listResourceDefinitionVersionsAsync(
            ListResourceDefinitionVersionsRequest listResourceDefinitionVersionsRequest);

    /**
     * Lists the versions of a resource definition.
     * 
     * @param listResourceDefinitionVersionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListResourceDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.ListResourceDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listResourceDefinitionVersionsAsync(
            ListResourceDefinitionVersionsRequest listResourceDefinitionVersionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves a list of resource definitions.
     * 
     * @param listResourceDefinitionsRequest
     * @return A Java Future containing the result of the ListResourceDefinitions operation returned by the service.
     * @sample AWSGreengrassAsync.ListResourceDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listResourceDefinitionsAsync(ListResourceDefinitionsRequest listResourceDefinitionsRequest);

    /**
     * Retrieves a list of resource definitions.
     * 
     * @param listResourceDefinitionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListResourceDefinitions operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListResourceDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listResourceDefinitionsAsync(ListResourceDefinitionsRequest listResourceDefinitionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Lists the versions of a subscription definition.
     * 
     * @param listSubscriptionDefinitionVersionsRequest
     * @return A Java Future containing the result of the ListSubscriptionDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.ListSubscriptionDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listSubscriptionDefinitionVersionsAsync(
            ListSubscriptionDefinitionVersionsRequest listSubscriptionDefinitionVersionsRequest);

    /**
     * Lists the versions of a subscription definition.
     * 
     * @param listSubscriptionDefinitionVersionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListSubscriptionDefinitionVersions operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.ListSubscriptionDefinitionVersions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listSubscriptionDefinitionVersionsAsync(
            ListSubscriptionDefinitionVersionsRequest listSubscriptionDefinitionVersionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Retrieves a list of subscription definitions.
     * 
     * @param listSubscriptionDefinitionsRequest
     * @return A Java Future containing the result of the ListSubscriptionDefinitions operation returned by the service.
     * @sample AWSGreengrassAsync.ListSubscriptionDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listSubscriptionDefinitionsAsync(
            ListSubscriptionDefinitionsRequest listSubscriptionDefinitionsRequest);

    /**
     * Retrieves a list of subscription definitions.
     * 
     * @param listSubscriptionDefinitionsRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ListSubscriptionDefinitions operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ListSubscriptionDefinitions
     * @see AWS API Documentation
     */
    java.util.concurrent.Future listSubscriptionDefinitionsAsync(
            ListSubscriptionDefinitionsRequest listSubscriptionDefinitionsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Resets a group's deployments.
     * 
     * @param resetDeploymentsRequest
     *        Information needed to reset deployments.
     * @return A Java Future containing the result of the ResetDeployments operation returned by the service.
     * @sample AWSGreengrassAsync.ResetDeployments
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future resetDeploymentsAsync(ResetDeploymentsRequest resetDeploymentsRequest);

    /**
     * Resets a group's deployments.
     * 
     * @param resetDeploymentsRequest
     *        Information needed to reset deployments.
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the ResetDeployments operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.ResetDeployments
     * @see AWS
     *      API Documentation
     */
    java.util.concurrent.Future resetDeploymentsAsync(ResetDeploymentsRequest resetDeploymentsRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Updates the connectivity information for the core. Any devices that belong to the group which has this core will
     * receive this information in order to find the location of the core and connect to it.
     * 
     * @param updateConnectivityInfoRequest
     *        Connectivity information.
     * @return A Java Future containing the result of the UpdateConnectivityInfo operation returned by the service.
     * @sample AWSGreengrassAsync.UpdateConnectivityInfo
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateConnectivityInfoAsync(UpdateConnectivityInfoRequest updateConnectivityInfoRequest);

    /**
     * Updates the connectivity information for the core. Any devices that belong to the group which has this core will
     * receive this information in order to find the location of the core and connect to it.
     * 
     * @param updateConnectivityInfoRequest
     *        Connectivity information.
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateConnectivityInfo operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.UpdateConnectivityInfo
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateConnectivityInfoAsync(UpdateConnectivityInfoRequest updateConnectivityInfoRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Updates a core definition.
     * 
     * @param updateCoreDefinitionRequest
     * @return A Java Future containing the result of the UpdateCoreDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.UpdateCoreDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateCoreDefinitionAsync(UpdateCoreDefinitionRequest updateCoreDefinitionRequest);

    /**
     * Updates a core definition.
     * 
     * @param updateCoreDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateCoreDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.UpdateCoreDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateCoreDefinitionAsync(UpdateCoreDefinitionRequest updateCoreDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Updates a device definition.
     * 
     * @param updateDeviceDefinitionRequest
     * @return A Java Future containing the result of the UpdateDeviceDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.UpdateDeviceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateDeviceDefinitionAsync(UpdateDeviceDefinitionRequest updateDeviceDefinitionRequest);

    /**
     * Updates a device definition.
     * 
     * @param updateDeviceDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateDeviceDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.UpdateDeviceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateDeviceDefinitionAsync(UpdateDeviceDefinitionRequest updateDeviceDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Updates a Lambda function definition.
     * 
     * @param updateFunctionDefinitionRequest
     * @return A Java Future containing the result of the UpdateFunctionDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.UpdateFunctionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateFunctionDefinitionAsync(UpdateFunctionDefinitionRequest updateFunctionDefinitionRequest);

    /**
     * Updates a Lambda function definition.
     * 
     * @param updateFunctionDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateFunctionDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.UpdateFunctionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateFunctionDefinitionAsync(UpdateFunctionDefinitionRequest updateFunctionDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Updates a group.
     * 
     * @param updateGroupRequest
     * @return A Java Future containing the result of the UpdateGroup operation returned by the service.
     * @sample AWSGreengrassAsync.UpdateGroup
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future updateGroupAsync(UpdateGroupRequest updateGroupRequest);

    /**
     * Updates a group.
     * 
     * @param updateGroupRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateGroup operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.UpdateGroup
     * @see AWS API
     *      Documentation
     */
    java.util.concurrent.Future updateGroupAsync(UpdateGroupRequest updateGroupRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Updates the Certificate expiry time for a group.
     * 
     * @param updateGroupCertificateConfigurationRequest
     * @return A Java Future containing the result of the UpdateGroupCertificateConfiguration operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.UpdateGroupCertificateConfiguration
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateGroupCertificateConfigurationAsync(
            UpdateGroupCertificateConfigurationRequest updateGroupCertificateConfigurationRequest);

    /**
     * Updates the Certificate expiry time for a group.
     * 
     * @param updateGroupCertificateConfigurationRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateGroupCertificateConfiguration operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.UpdateGroupCertificateConfiguration
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateGroupCertificateConfigurationAsync(
            UpdateGroupCertificateConfigurationRequest updateGroupCertificateConfigurationRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Updates a logger definition.
     * 
     * @param updateLoggerDefinitionRequest
     * @return A Java Future containing the result of the UpdateLoggerDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.UpdateLoggerDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateLoggerDefinitionAsync(UpdateLoggerDefinitionRequest updateLoggerDefinitionRequest);

    /**
     * Updates a logger definition.
     * 
     * @param updateLoggerDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateLoggerDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.UpdateLoggerDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateLoggerDefinitionAsync(UpdateLoggerDefinitionRequest updateLoggerDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Updates a resource definition.
     * 
     * @param updateResourceDefinitionRequest
     * @return A Java Future containing the result of the UpdateResourceDefinition operation returned by the service.
     * @sample AWSGreengrassAsync.UpdateResourceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateResourceDefinitionAsync(UpdateResourceDefinitionRequest updateResourceDefinitionRequest);

    /**
     * Updates a resource definition.
     * 
     * @param updateResourceDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateResourceDefinition operation returned by the service.
     * @sample AWSGreengrassAsyncHandler.UpdateResourceDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateResourceDefinitionAsync(UpdateResourceDefinitionRequest updateResourceDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

    /**
     * Updates a subscription definition.
     * 
     * @param updateSubscriptionDefinitionRequest
     * @return A Java Future containing the result of the UpdateSubscriptionDefinition operation returned by the
     *         service.
     * @sample AWSGreengrassAsync.UpdateSubscriptionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateSubscriptionDefinitionAsync(
            UpdateSubscriptionDefinitionRequest updateSubscriptionDefinitionRequest);

    /**
     * Updates a subscription definition.
     * 
     * @param updateSubscriptionDefinitionRequest
     * @param asyncHandler
     *        Asynchronous callback handler for events in the lifecycle of the request. Users can provide an
     *        implementation of the callback methods in this interface to receive notification of successful or
     *        unsuccessful completion of the operation.
     * @return A Java Future containing the result of the UpdateSubscriptionDefinition operation returned by the
     *         service.
     * @sample AWSGreengrassAsyncHandler.UpdateSubscriptionDefinition
     * @see AWS API Documentation
     */
    java.util.concurrent.Future updateSubscriptionDefinitionAsync(
            UpdateSubscriptionDefinitionRequest updateSubscriptionDefinitionRequest,
            com.amazonaws.handlers.AsyncHandler asyncHandler);

}