text:
package com.amazonaws.services.sqs;

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

/**
 * Interface for accessing Amazon SQS 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.
 *

 *

 * Welcome to the Amazon Simple Queue Service API Reference. This section
 * describes who should read this guide, how the guide is organized, and other
 * resources related to the Amazon Simple Queue Service (Amazon SQS).
 *

 *

 * Amazon SQS offers reliable and scalable hosted queues for storing messages as
 * they travel between computers. By using Amazon SQS, you can move data between
 * distributed components of your applications that perform different tasks
 * without losing messages or requiring each component to be always available.
 *

 *

 * Helpful Links:
 *

 *
Current
 * WSDL (2012-11-05)

 *
Making API Requests

 *
Amazon SQS product page

 *
Using Amazon SQS Message Attributes

 *
Using Amazon SQS Dead Letter Queues

 *
Regions and Endpoints

 *

 *

 *

 * We also provide SDKs that enable you to access Amazon SQS from your preferred
 * programming language. The SDKs contain functionality that automatically takes
 * care of tasks such as:
 *

 *

 *

 *
Cryptographically signing your service requests

 *
Retrying requests

 *
Handling error responses

 *

 *

 *

 * For a list of available SDKs, go to Tools for Amazon Web Services.
 *

 */
public interface AmazonSQSAsync extends AmazonSQS {

    /**
     *

     * Adds a permission to a queue for a specific principal. This allows for sharing access to the queue.
     *

     *

     * When you create a queue, you have full control access rights for the
     * queue. Only you (as owner of the queue) can grant or deny permissions to
     * the queue. For more information about these permissions, see Shared Queues in the Amazon SQS Developer Guide.
     *

     * <note>
     *

     * AddPermission writes an Amazon SQS-generated policy. If you
     * want to write your own policy, use SetQueueAttributes to upload
     * your policy. For more information about writing your own policy, see Using The Access Policy Language in the Amazon SQS Developer
     * Guide.
     *

     * </note> <note>Some API actions take lists of parameters. These lists are
     * specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param addPermissionRequest
     * @sample AmazonSQSAsync.AddPermission
     */
    java.util.concurrent.Future<Void> addPermissionAsync(
            AddPermissionRequest addPermissionRequest);

    /**
     *

     * Adds a permission to a queue for a specific principal. This allows for sharing access to the queue.
     *

     *

     * When you create a queue, you have full control access rights for the
     * queue. Only you (as owner of the queue) can grant or deny permissions to
     * the queue. For more information about these permissions, see Shared Queues in the Amazon SQS Developer Guide.
     *

     * <note>
     *

     * AddPermission writes an Amazon SQS-generated policy. If you
     * want to write your own policy, use SetQueueAttributes to upload
     * your policy. For more information about writing your own policy, see Using The Access Policy Language in the Amazon SQS Developer
     * Guide.
     *

     * </note> <note>Some API actions take lists of parameters. These lists are
     * specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param addPermissionRequest
     * @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.
     * @sample AmazonSQSAsyncHandler.AddPermission
     */
    java.util.concurrent.Future<Void> addPermissionAsync(
            AddPermissionRequest addPermissionRequest,
            com.amazonaws.handlers.AsyncHandler<AddPermissionRequest, Void> asyncHandler);

    /**
     * Simplified method form for invoking the AddPermission operation.
     *
     * @see #addPermissionAsync(AddPermissionRequest)
     */
    java.util.concurrent.Future<Void> addPermissionAsync(String queueUrl,
            String label, java.util.List<String> aWSAccountIds,
            java.util.List<String> actions);

    /**
     * Simplified method form for invoking the AddPermission operation with an
     * AsyncHandler.
     *
     * @see #addPermissionAsync(AddPermissionRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<Void> addPermissionAsync(
            String queueUrl,
            String label,
            java.util.List<String> aWSAccountIds,
            java.util.List<String> actions,
            com.amazonaws.handlers.AsyncHandler<AddPermissionRequest, Void> asyncHandler);

    /**
     *

     * Changes the visibility timeout of a specified message in a queue to a new
     * value. The maximum allowed timeout value you can set the value to is 12
     * hours. This means you can't extend the timeout of a message in an
     * existing queue to more than a total visibility timeout of 12 hours. (For
     * more information visibility timeout, see Visibility Timeout in the Amazon SQS Developer Guide.)
     *

     *

     * For example, let's say you have a message and its default message
     * visibility timeout is 5 minutes. After 3 minutes, you call
     * ChangeMessageVisiblity with a timeout of 10 minutes. At that
     * time, the timeout for the message would be extended by 10 minutes beyond
     * the time of the ChangeMessageVisibility call. This results in a total
     * visibility timeout of 13 minutes. You can continue to call
     * ChangeMessageVisibility to extend the visibility timeout to a maximum of
     * 12 hours. If you try to extend beyond 12 hours, the request will be
     * rejected.
     *

     * <note>
     *

     * There is a 120,000 limit for the number of inflight messages per queue.
     * Messages are inflight after they have been received from the queue by a
     * consuming component, but have not yet been deleted from the queue. If you
     * reach the 120,000 limit, you will receive an OverLimit error message from
     * Amazon SQS. To help avoid reaching the limit, you should delete the
     * messages from the queue after they have been processed. You can also
     * increase the number of queues you use to process the messages.
     *

     * </note> <important>If you attempt to set the
     * VisibilityTimeout to an amount more than the maximum time
     * left, Amazon SQS returns an error. It will not automatically recalculate
     * and increase the timeout to the maximum time remaining.</important>
     * <important>Unlike with a queue, when you change the visibility timeout
     * for a specific message, that timeout value is applied immediately but is
     * not saved in memory for that message. If you don't delete a message after
     * it is received, the visibility timeout for the message the next time it
     * is received reverts to the original timeout value, not the value you set
     * with the ChangeMessageVisibility action.</important>
     *
     * @param changeMessageVisibilityRequest
     * @sample AmazonSQSAsync.ChangeMessageVisibility
     */
    java.util.concurrent.Future<Void> changeMessageVisibilityAsync(
            ChangeMessageVisibilityRequest changeMessageVisibilityRequest);

    /**
     *

     * Changes the visibility timeout of a specified message in a queue to a new
     * value. The maximum allowed timeout value you can set the value to is 12
     * hours. This means you can't extend the timeout of a message in an
     * existing queue to more than a total visibility timeout of 12 hours. (For
     * more information visibility timeout, see Visibility Timeout in the Amazon SQS Developer Guide.)
     *

     *

     * For example, let's say you have a message and its default message
     * visibility timeout is 5 minutes. After 3 minutes, you call
     * ChangeMessageVisiblity with a timeout of 10 minutes. At that
     * time, the timeout for the message would be extended by 10 minutes beyond
     * the time of the ChangeMessageVisibility call. This results in a total
     * visibility timeout of 13 minutes. You can continue to call
     * ChangeMessageVisibility to extend the visibility timeout to a maximum of
     * 12 hours. If you try to extend beyond 12 hours, the request will be
     * rejected.
     *

     * <note>
     *

     * There is a 120,000 limit for the number of inflight messages per queue.
     * Messages are inflight after they have been received from the queue by a
     * consuming component, but have not yet been deleted from the queue. If you
     * reach the 120,000 limit, you will receive an OverLimit error message from
     * Amazon SQS. To help avoid reaching the limit, you should delete the
     * messages from the queue after they have been processed. You can also
     * increase the number of queues you use to process the messages.
     *

     * </note> <important>If you attempt to set the
     * VisibilityTimeout to an amount more than the maximum time
     * left, Amazon SQS returns an error. It will not automatically recalculate
     * and increase the timeout to the maximum time remaining.</important>
     * <important>Unlike with a queue, when you change the visibility timeout
     * for a specific message, that timeout value is applied immediately but is
     * not saved in memory for that message. If you don't delete a message after
     * it is received, the visibility timeout for the message the next time it
     * is received reverts to the original timeout value, not the value you set
     * with the ChangeMessageVisibility action.</important>
     *
     * @param changeMessageVisibilityRequest
     * @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.
     * @sample AmazonSQSAsyncHandler.ChangeMessageVisibility
     */
    java.util.concurrent.Future<Void> changeMessageVisibilityAsync(
            ChangeMessageVisibilityRequest changeMessageVisibilityRequest,
            com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityRequest, Void> asyncHandler);

    /**
     * Simplified method form for invoking the ChangeMessageVisibility
     * operation.
     *
     * @see #changeMessageVisibilityAsync(ChangeMessageVisibilityRequest)
     */
    java.util.concurrent.Future<Void> changeMessageVisibilityAsync(
            String queueUrl, String receiptHandle, Integer visibilityTimeout);

    /**
     * Simplified method form for invoking the ChangeMessageVisibility operation
     * with an AsyncHandler.
     *
     * @see #changeMessageVisibilityAsync(ChangeMessageVisibilityRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<Void> changeMessageVisibilityAsync(
            String queueUrl,
            String receiptHandle,
            Integer visibilityTimeout,
            com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityRequest, Void> asyncHandler);

    /**
     *

     * Changes the visibility timeout of multiple messages. This is a batch
     * version of ChangeMessageVisibility. The result of the action on
     * each message is reported individually in the response. You can send up to
     * 10 ChangeMessageVisibility requests with each
     * ChangeMessageVisibilityBatch action.
     *

     * <important>Because the batch request can result in a combination of
     * successful and unsuccessful actions, you should check for batch errors
     * even when the call returns an HTTP status code of 200.</important>
     * <note>Some API actions take lists of parameters. These lists are
     * specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param changeMessageVisibilityBatchRequest
     * @return A Java Future containing the result of the
     *         ChangeMessageVisibilityBatch operation returned by the service.
     * @sample AmazonSQSAsync.ChangeMessageVisibilityBatch
     */
    java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync(
            ChangeMessageVisibilityBatchRequest changeMessageVisibilityBatchRequest);

    /**
     *

     * Changes the visibility timeout of multiple messages. This is a batch
     * version of ChangeMessageVisibility. The result of the action on
     * each message is reported individually in the response. You can send up to
     * 10 ChangeMessageVisibility requests with each
     * ChangeMessageVisibilityBatch action.
     *

     * <important>Because the batch request can result in a combination of
     * successful and unsuccessful actions, you should check for batch errors
     * even when the call returns an HTTP status code of 200.</important>
     * <note>Some API actions take lists of parameters. These lists are
     * specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param changeMessageVisibilityBatchRequest
     * @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
     *         ChangeMessageVisibilityBatch operation returned by the service.
     * @sample AmazonSQSAsyncHandler.ChangeMessageVisibilityBatch
     */
    java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync(
            ChangeMessageVisibilityBatchRequest changeMessageVisibilityBatchRequest,
            com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityBatchRequest, ChangeMessageVisibilityBatchResult> asyncHandler);

    /**
     * Simplified method form for invoking the ChangeMessageVisibilityBatch
     * operation.
     *
     * @see #changeMessageVisibilityBatchAsync(ChangeMessageVisibilityBatchRequest)
     */
    java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync(
            String queueUrl,
            java.util.List<ChangeMessageVisibilityBatchRequestEntry> entries);

    /**
     * Simplified method form for invoking the ChangeMessageVisibilityBatch
     * operation with an AsyncHandler.
     *
     * @see #changeMessageVisibilityBatchAsync(ChangeMessageVisibilityBatchRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync(
            String queueUrl,
            java.util.List<ChangeMessageVisibilityBatchRequestEntry> entries,
            com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityBatchRequest, ChangeMessageVisibilityBatchResult> asyncHandler);

    /**
     *

     * Creates a new queue, or returns the URL of an existing one. When you
     * request CreateQueue, you provide a name for the queue. To
     * successfully create a new queue, you must provide a name that is unique
     * within the scope of your own queues.
     *

     * <note>
     *

     * If you delete a queue, you must wait at least 60 seconds before creating
     * a queue with the same name.
     *

     * </note>
     *

     * You may pass one or more attributes in the request. If you do not provide
     * a value for any attribute, the queue will have the default value for that
     * attribute. Permitted attributes are the same that can be set using
     * SetQueueAttributes.
     *

     * <note>
     *

     * Use GetQueueUrl to get a queue's URL. GetQueueUrl requires
     * only the QueueName parameter.
     *

     * </note>
     *

     * If you provide the name of an existing queue, along with the exact names
     * and values of all the queue's attributes, CreateQueue
     * returns the queue URL for the existing queue. If the queue name,
     * attribute names, or attribute values do not match an existing queue,
     * CreateQueue returns an error.
     *

     * <note>Some API actions take lists of parameters. These lists are
     * specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param createQueueRequest
     * @return A Java Future containing the result of the CreateQueue operation
     *         returned by the service.
     * @sample AmazonSQSAsync.CreateQueue
     */
    java.util.concurrent.Future<CreateQueueResult> createQueueAsync(
            CreateQueueRequest createQueueRequest);

    /**
     *

     * Creates a new queue, or returns the URL of an existing one. When you
     * request CreateQueue, you provide a name for the queue. To
     * successfully create a new queue, you must provide a name that is unique
     * within the scope of your own queues.
     *

     * <note>
     *

     * If you delete a queue, you must wait at least 60 seconds before creating
     * a queue with the same name.
     *

     * </note>
     *

     * You may pass one or more attributes in the request. If you do not provide
     * a value for any attribute, the queue will have the default value for that
     * attribute. Permitted attributes are the same that can be set using
     * SetQueueAttributes.
     *

     * <note>
     *

     * Use GetQueueUrl to get a queue's URL. GetQueueUrl requires
     * only the QueueName parameter.
     *

     * </note>
     *

     * If you provide the name of an existing queue, along with the exact names
     * and values of all the queue's attributes, CreateQueue
     * returns the queue URL for the existing queue. If the queue name,
     * attribute names, or attribute values do not match an existing queue,
     * CreateQueue returns an error.
     *

     * <note>Some API actions take lists of parameters. These lists are
     * specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param createQueueRequest
     * @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 CreateQueue operation
     *         returned by the service.
     * @sample AmazonSQSAsyncHandler.CreateQueue
     */
    java.util.concurrent.Future<CreateQueueResult> createQueueAsync(
            CreateQueueRequest createQueueRequest,
            com.amazonaws.handlers.AsyncHandler<CreateQueueRequest, CreateQueueResult> asyncHandler);

    /**
     * Simplified method form for invoking the CreateQueue operation.
     *
     * @see #createQueueAsync(CreateQueueRequest)
     */
    java.util.concurrent.Future<CreateQueueResult> createQueueAsync(
            String queueName);

    /**
     * Simplified method form for invoking the CreateQueue operation with an
     * AsyncHandler.
     *
     * @see #createQueueAsync(CreateQueueRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<CreateQueueResult> createQueueAsync(
            String queueName,
            com.amazonaws.handlers.AsyncHandler<CreateQueueRequest, CreateQueueResult> asyncHandler);

    /**
     *

     * Deletes the specified message from the specified queue. You specify the
     * message by using the message's receipt handle and not the
     * message ID you received when you sent the message. Even if
     * the message is locked by another reader due to the visibility timeout
     * setting, it is still deleted from the queue. If you leave a message in
     * the queue for longer than the queue's configured retention period, Amazon
     * SQS automatically deletes it.
     *

     * <note>
     *

     * The receipt handle is associated with a specific instance of receiving
     * the message. If you receive a message more than once, the receipt handle
     * you get each time you receive the message is different. When you request
     * DeleteMessage, if you don't provide the most recently
     * received receipt handle for the message, the request will still succeed,
     * but the message might not be deleted.
     *

     * </note> <important>
     *

     * It is possible you will receive a message even after you have deleted it.
     * This might happen on rare occasions if one of the servers storing a copy
     * of the message is unavailable when you request to delete the message. The
     * copy remains on the server and might be returned to you again on a
     * subsequent receive request. You should create your system to be
     * idempotent so that receiving a particular message more than once is not a
     * problem.
     *

     * </important>
     *
     * @param deleteMessageRequest
     * @sample AmazonSQSAsync.DeleteMessage
     */
    java.util.concurrent.Future<Void> deleteMessageAsync(
            DeleteMessageRequest deleteMessageRequest);

    /**
     *

     * Deletes the specified message from the specified queue. You specify the
     * message by using the message's receipt handle and not the
     * message ID you received when you sent the message. Even if
     * the message is locked by another reader due to the visibility timeout
     * setting, it is still deleted from the queue. If you leave a message in
     * the queue for longer than the queue's configured retention period, Amazon
     * SQS automatically deletes it.
     *

     * <note>
     *

     * The receipt handle is associated with a specific instance of receiving
     * the message. If you receive a message more than once, the receipt handle
     * you get each time you receive the message is different. When you request
     * DeleteMessage, if you don't provide the most recently
     * received receipt handle for the message, the request will still succeed,
     * but the message might not be deleted.
     *

     * </note> <important>
     *

     * It is possible you will receive a message even after you have deleted it.
     * This might happen on rare occasions if one of the servers storing a copy
     * of the message is unavailable when you request to delete the message. The
     * copy remains on the server and might be returned to you again on a
     * subsequent receive request. You should create your system to be
     * idempotent so that receiving a particular message more than once is not a
     * problem.
     *

     * </important>
     *
     * @param deleteMessageRequest
     * @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.
     * @sample AmazonSQSAsyncHandler.DeleteMessage
     */
    java.util.concurrent.Future<Void> deleteMessageAsync(
            DeleteMessageRequest deleteMessageRequest,
            com.amazonaws.handlers.AsyncHandler<DeleteMessageRequest, Void> asyncHandler);

    /**
     * Simplified method form for invoking the DeleteMessage operation.
     *
     * @see #deleteMessageAsync(DeleteMessageRequest)
     */
    java.util.concurrent.Future<Void> deleteMessageAsync(String queueUrl,
            String receiptHandle);

    /**
     * Simplified method form for invoking the DeleteMessage operation with an
     * AsyncHandler.
     *
     * @see #deleteMessageAsync(DeleteMessageRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<Void> deleteMessageAsync(
            String queueUrl,
            String receiptHandle,
            com.amazonaws.handlers.AsyncHandler<DeleteMessageRequest, Void> asyncHandler);

    /**
     *

     * Deletes up to ten messages from the specified queue. This is a batch
     * version of DeleteMessage. The result of the delete action on each
     * message is reported individually in the response.
     *

     * <important>
     *

     * Because the batch request can result in a combination of successful and
     * unsuccessful actions, you should check for batch errors even when the
     * call returns an HTTP status code of 200.
     *

     * </important> <note>Some API actions take lists of parameters. These lists
     * are specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param deleteMessageBatchRequest
     * @return A Java Future containing the result of the DeleteMessageBatch
     *         operation returned by the service.
     * @sample AmazonSQSAsync.DeleteMessageBatch
     */
    java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(
            DeleteMessageBatchRequest deleteMessageBatchRequest);

    /**
     *

     * Deletes up to ten messages from the specified queue. This is a batch
     * version of DeleteMessage. The result of the delete action on each
     * message is reported individually in the response.
     *

     * <important>
     *

     * Because the batch request can result in a combination of successful and
     * unsuccessful actions, you should check for batch errors even when the
     * call returns an HTTP status code of 200.
     *

     * </important> <note>Some API actions take lists of parameters. These lists
     * are specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param deleteMessageBatchRequest
     * @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 DeleteMessageBatch
     *         operation returned by the service.
     * @sample AmazonSQSAsyncHandler.DeleteMessageBatch
     */
    java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(
            DeleteMessageBatchRequest deleteMessageBatchRequest,
            com.amazonaws.handlers.AsyncHandler<DeleteMessageBatchRequest, DeleteMessageBatchResult> asyncHandler);

    /**
     * Simplified method form for invoking the DeleteMessageBatch operation.
     *
     * @see #deleteMessageBatchAsync(DeleteMessageBatchRequest)
     */
    java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(
            String queueUrl,
            java.util.List<DeleteMessageBatchRequestEntry> entries);

    /**
     * Simplified method form for invoking the DeleteMessageBatch operation with
     * an AsyncHandler.
     *
     * @see #deleteMessageBatchAsync(DeleteMessageBatchRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(
            String queueUrl,
            java.util.List<DeleteMessageBatchRequestEntry> entries,
            com.amazonaws.handlers.AsyncHandler<DeleteMessageBatchRequest, DeleteMessageBatchResult> asyncHandler);

    /**
     *

     * Deletes the queue specified by the queue URL, regardless of
     * whether the queue is empty. If the specified queue does not exist, Amazon
     * SQS returns a successful response.
     *

     * <important>
     *

     * Use DeleteQueue with care; once you delete your queue, any
     * messages in the queue are no longer available.
     *

     * </important>
     *

     * When you delete a queue, the deletion process takes up to 60 seconds.
     * Requests you send involving that queue during the 60 seconds might
     * succeed. For example, a SendMessage request might succeed, but
     * after the 60 seconds, the queue and that message you sent no longer
     * exist. Also, when you delete a queue, you must wait at least 60 seconds
     * before creating a queue with the same name.
     *

     *

     * We reserve the right to delete queues that have had no activity for more
     * than 30 days. For more information, see How Amazon SQS Queues Work in the Amazon SQS Developer Guide.
     *

     *
     * @param deleteQueueRequest
     * @sample AmazonSQSAsync.DeleteQueue
     */
    java.util.concurrent.Future<Void> deleteQueueAsync(
            DeleteQueueRequest deleteQueueRequest);

    /**
     *

     * Deletes the queue specified by the queue URL, regardless of
     * whether the queue is empty. If the specified queue does not exist, Amazon
     * SQS returns a successful response.
     *

     * <important>
     *

     * Use DeleteQueue with care; once you delete your queue, any
     * messages in the queue are no longer available.
     *

     * </important>
     *

     * When you delete a queue, the deletion process takes up to 60 seconds.
     * Requests you send involving that queue during the 60 seconds might
     * succeed. For example, a SendMessage request might succeed, but
     * after the 60 seconds, the queue and that message you sent no longer
     * exist. Also, when you delete a queue, you must wait at least 60 seconds
     * before creating a queue with the same name.
     *

     *

     * We reserve the right to delete queues that have had no activity for more
     * than 30 days. For more information, see How Amazon SQS Queues Work in the Amazon SQS Developer Guide.
     *

     *
     * @param deleteQueueRequest
     * @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.
     * @sample AmazonSQSAsyncHandler.DeleteQueue
     */
    java.util.concurrent.Future<Void> deleteQueueAsync(
            DeleteQueueRequest deleteQueueRequest,
            com.amazonaws.handlers.AsyncHandler<DeleteQueueRequest, Void> asyncHandler);

    /**
     * Simplified method form for invoking the DeleteQueue operation.
     *
     * @see #deleteQueueAsync(DeleteQueueRequest)
     */
    java.util.concurrent.Future<Void> deleteQueueAsync(String queueUrl);

    /**
     * Simplified method form for invoking the DeleteQueue operation with an
     * AsyncHandler.
     *
     * @see #deleteQueueAsync(DeleteQueueRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<Void> deleteQueueAsync(
            String queueUrl,
            com.amazonaws.handlers.AsyncHandler<DeleteQueueRequest, Void> asyncHandler);

    /**
     *

     * Gets attributes for the specified queue. The following attributes are
     * supported:
     *

     *
All - returns all values.

     *
ApproximateNumberOfMessages - returns the approximate
     * number of visible messages in a queue. For more information, see Resources Required to Process Messages in the Amazon SQS
     * Developer Guide.

     *
ApproximateNumberOfMessagesNotVisible - returns the
     * approximate number of messages that are not timed-out and not deleted.
     * For more information, see Resources Required to Process Messages in the Amazon SQS
     * Developer Guide.

     *
VisibilityTimeout - returns the visibility timeout for
     * the queue. For more information about visibility timeout, see Visibility Timeout in the Amazon SQS Developer Guide.

     *
CreatedTimestamp - returns the time when the queue was
     * created (epoch time in seconds).

     *
LastModifiedTimestamp - returns the time when the queue
     * was last changed (epoch time in seconds).

     *
Policy - returns the queue's policy.

     *
MaximumMessageSize - returns the limit of how many bytes
     * a message can contain before Amazon SQS rejects it.

     *
MessageRetentionPeriod - returns the number of seconds
     * Amazon SQS retains a message.

     *
QueueArn - returns the queue's Amazon resource name
     * (ARN).

     *
ApproximateNumberOfMessagesDelayed - returns the
     * approximate number of messages that are pending to be added to the queue.
     *

     *
DelaySeconds - returns the default delay on the queue in
     * seconds.

     *
ReceiveMessageWaitTimeSeconds - returns the time for
     * which a ReceiveMessage call will wait for a message to arrive.

     *
RedrivePolicy - returns the parameters for dead letter
     * queue functionality of the source queue. For more information about
     * RedrivePolicy and dead letter queues, see Using Amazon SQS Dead Letter Queues in the Amazon SQS Developer
     * Guide.

     *

     *

     * <note>Going forward, new attributes might be added. If you are writing
     * code that calls this action, we recommend that you structure your code so
     * that it can handle new attributes gracefully.</note> <note>Some API
     * actions take lists of parameters. These lists are specified using the
     * param.n notation. Values of n are integers
     * starting from 1. For example, a parameter list with two elements looks
     * like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param getQueueAttributesRequest
     * @return A Java Future containing the result of the GetQueueAttributes
     *         operation returned by the service.
     * @sample AmazonSQSAsync.GetQueueAttributes
     */
    java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(
            GetQueueAttributesRequest getQueueAttributesRequest);

    /**
     *

     * Gets attributes for the specified queue. The following attributes are
     * supported:
     *

     *
All - returns all values.

     *
ApproximateNumberOfMessages - returns the approximate
     * number of visible messages in a queue. For more information, see Resources Required to Process Messages in the Amazon SQS
     * Developer Guide.

     *
ApproximateNumberOfMessagesNotVisible - returns the
     * approximate number of messages that are not timed-out and not deleted.
     * For more information, see Resources Required to Process Messages in the Amazon SQS
     * Developer Guide.

     *
VisibilityTimeout - returns the visibility timeout for
     * the queue. For more information about visibility timeout, see Visibility Timeout in the Amazon SQS Developer Guide.

     *
CreatedTimestamp - returns the time when the queue was
     * created (epoch time in seconds).

     *
LastModifiedTimestamp - returns the time when the queue
     * was last changed (epoch time in seconds).

     *
Policy - returns the queue's policy.

     *
MaximumMessageSize - returns the limit of how many bytes
     * a message can contain before Amazon SQS rejects it.

     *
MessageRetentionPeriod - returns the number of seconds
     * Amazon SQS retains a message.

     *
QueueArn - returns the queue's Amazon resource name
     * (ARN).

     *
ApproximateNumberOfMessagesDelayed - returns the
     * approximate number of messages that are pending to be added to the queue.
     *

     *
DelaySeconds - returns the default delay on the queue in
     * seconds.

     *
ReceiveMessageWaitTimeSeconds - returns the time for
     * which a ReceiveMessage call will wait for a message to arrive.

     *
RedrivePolicy - returns the parameters for dead letter
     * queue functionality of the source queue. For more information about
     * RedrivePolicy and dead letter queues, see Using Amazon SQS Dead Letter Queues in the Amazon SQS Developer
     * Guide.

     *

     *

     * <note>Going forward, new attributes might be added. If you are writing
     * code that calls this action, we recommend that you structure your code so
     * that it can handle new attributes gracefully.</note> <note>Some API
     * actions take lists of parameters. These lists are specified using the
     * param.n notation. Values of n are integers
     * starting from 1. For example, a parameter list with two elements looks
     * like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param getQueueAttributesRequest
     * @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 GetQueueAttributes
     *         operation returned by the service.
     * @sample AmazonSQSAsyncHandler.GetQueueAttributes
     */
    java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(
            GetQueueAttributesRequest getQueueAttributesRequest,
            com.amazonaws.handlers.AsyncHandler<GetQueueAttributesRequest, GetQueueAttributesResult> asyncHandler);

    /**
     * Simplified method form for invoking the GetQueueAttributes operation.
     *
     * @see #getQueueAttributesAsync(GetQueueAttributesRequest)
     */
    java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(
            String queueUrl, java.util.List<String> attributeNames);

    /**
     * Simplified method form for invoking the GetQueueAttributes operation with
     * an AsyncHandler.
     *
     * @see #getQueueAttributesAsync(GetQueueAttributesRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(
            String queueUrl,
            java.util.List<String> attributeNames,
            com.amazonaws.handlers.AsyncHandler<GetQueueAttributesRequest, GetQueueAttributesResult> asyncHandler);

    /**
     *

     * Returns the URL of an existing queue. This action provides a simple way
     * to retrieve the URL of an Amazon SQS queue.
     *

     *

     * To access a queue that belongs to another AWS account, use the
     * QueueOwnerAWSAccountId parameter to specify the account ID
     * of the queue's owner. The queue's owner must grant you permission to
     * access the queue. For more information about shared queue access, see
     * AddPermission or go to Shared Queues in the Amazon SQS Developer Guide.
     *

     *
     * @param getQueueUrlRequest
     * @return A Java Future containing the result of the GetQueueUrl operation
     *         returned by the service.
     * @sample AmazonSQSAsync.GetQueueUrl
     */
    java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(
            GetQueueUrlRequest getQueueUrlRequest);

    /**
     *

     * Returns the URL of an existing queue. This action provides a simple way
     * to retrieve the URL of an Amazon SQS queue.
     *

     *

     * To access a queue that belongs to another AWS account, use the
     * QueueOwnerAWSAccountId parameter to specify the account ID
     * of the queue's owner. The queue's owner must grant you permission to
     * access the queue. For more information about shared queue access, see
     * AddPermission or go to Shared Queues in the Amazon SQS Developer Guide.
     *

     *
     * @param getQueueUrlRequest
     * @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 GetQueueUrl operation
     *         returned by the service.
     * @sample AmazonSQSAsyncHandler.GetQueueUrl
     */
    java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(
            GetQueueUrlRequest getQueueUrlRequest,
            com.amazonaws.handlers.AsyncHandler<GetQueueUrlRequest, GetQueueUrlResult> asyncHandler);

    /**
     * Simplified method form for invoking the GetQueueUrl operation.
     *
     * @see #getQueueUrlAsync(GetQueueUrlRequest)
     */
    java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(
            String queueName);

    /**
     * Simplified method form for invoking the GetQueueUrl operation with an
     * AsyncHandler.
     *
     * @see #getQueueUrlAsync(GetQueueUrlRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(
            String queueName,
            com.amazonaws.handlers.AsyncHandler<GetQueueUrlRequest, GetQueueUrlResult> asyncHandler);

    /**
     *

     * Returns a list of your queues that have the RedrivePolicy queue attribute
     * configured with a dead letter queue.
     *

     *

     * For more information about using dead letter queues, see Using Amazon SQS Dead Letter Queues.
     *

     *
     * @param listDeadLetterSourceQueuesRequest
     * @return A Java Future containing the result of the
     *         ListDeadLetterSourceQueues operation returned by the service.
     * @sample AmazonSQSAsync.ListDeadLetterSourceQueues
     */
    java.util.concurrent.Future<ListDeadLetterSourceQueuesResult> listDeadLetterSourceQueuesAsync(
            ListDeadLetterSourceQueuesRequest listDeadLetterSourceQueuesRequest);

    /**
     *

     * Returns a list of your queues that have the RedrivePolicy queue attribute
     * configured with a dead letter queue.
     *

     *

     * For more information about using dead letter queues, see Using Amazon SQS Dead Letter Queues.
     *

     *
     * @param listDeadLetterSourceQueuesRequest
     * @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
     *         ListDeadLetterSourceQueues operation returned by the service.
     * @sample AmazonSQSAsyncHandler.ListDeadLetterSourceQueues
     */
    java.util.concurrent.Future<ListDeadLetterSourceQueuesResult> listDeadLetterSourceQueuesAsync(
            ListDeadLetterSourceQueuesRequest listDeadLetterSourceQueuesRequest,
            com.amazonaws.handlers.AsyncHandler<ListDeadLetterSourceQueuesRequest, ListDeadLetterSourceQueuesResult> asyncHandler);

    /**
     *

     * Returns a list of your queues. The maximum number of queues that can be
     * returned is 1000. If you specify a value for the optional
     * QueueNamePrefix parameter, only queues with a name beginning
     * with the specified value are returned.
     *

     *
     * @param listQueuesRequest
     * @return A Java Future containing the result of the ListQueues operation
     *         returned by the service.
     * @sample AmazonSQSAsync.ListQueues
     */
    java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(
            ListQueuesRequest listQueuesRequest);

    /**
     *

     * Returns a list of your queues. The maximum number of queues that can be
     * returned is 1000. If you specify a value for the optional
     * QueueNamePrefix parameter, only queues with a name beginning
     * with the specified value are returned.
     *

     *
     * @param listQueuesRequest
     * @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 ListQueues operation
     *         returned by the service.
     * @sample AmazonSQSAsyncHandler.ListQueues
     */
    java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(
            ListQueuesRequest listQueuesRequest,
            com.amazonaws.handlers.AsyncHandler<ListQueuesRequest, ListQueuesResult> asyncHandler);

    /**
     * Simplified method form for invoking the ListQueues operation.
     *
     * @see #listQueuesAsync(ListQueuesRequest)
     */
    java.util.concurrent.Future<ListQueuesResult> listQueuesAsync();

    /**
     * Simplified method form for invoking the ListQueues operation with an
     * AsyncHandler.
     *
     * @see #listQueuesAsync(ListQueuesRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(
            com.amazonaws.handlers.AsyncHandler<ListQueuesRequest, ListQueuesResult> asyncHandler);

    /**
     * Simplified method form for invoking the ListQueues operation.
     *
     * @see #listQueuesAsync(ListQueuesRequest)
     */
    java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(
            String queueNamePrefix);

    /**
     * Simplified method form for invoking the ListQueues operation with an
     * AsyncHandler.
     *
     * @see #listQueuesAsync(ListQueuesRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(
            String queueNamePrefix,
            com.amazonaws.handlers.AsyncHandler<ListQueuesRequest, ListQueuesResult> asyncHandler);

    /**
     *

     * Deletes the messages in a queue specified by the queue URL.
     *

     * <important>When you use the PurgeQueue API, the deleted
     * messages in the queue cannot be retrieved.</important>
     *

     * When you purge a queue, the message deletion process takes up to 60
     * seconds. All messages sent to the queue before calling
     * PurgeQueue will be deleted; messages sent to the queue while
     * it is being purged may be deleted. While the queue is being purged,
     * messages sent to the queue before PurgeQueue was called may
     * be received, but will be deleted within the next minute.
     *

     *
     * @param purgeQueueRequest
     * @sample AmazonSQSAsync.PurgeQueue
     */
    java.util.concurrent.Future<Void> purgeQueueAsync(
            PurgeQueueRequest purgeQueueRequest);

    /**
     *

     * Deletes the messages in a queue specified by the queue URL.
     *

     * <important>When you use the PurgeQueue API, the deleted
     * messages in the queue cannot be retrieved.</important>
     *

     * When you purge a queue, the message deletion process takes up to 60
     * seconds. All messages sent to the queue before calling
     * PurgeQueue will be deleted; messages sent to the queue while
     * it is being purged may be deleted. While the queue is being purged,
     * messages sent to the queue before PurgeQueue was called may
     * be received, but will be deleted within the next minute.
     *

     *
     * @param purgeQueueRequest
     * @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.
     * @sample AmazonSQSAsyncHandler.PurgeQueue
     */
    java.util.concurrent.Future<Void> purgeQueueAsync(
            PurgeQueueRequest purgeQueueRequest,
            com.amazonaws.handlers.AsyncHandler<PurgeQueueRequest, Void> asyncHandler);

    /**
     *

     * Retrieves one or more messages, with a maximum limit of 10 messages, from
     * the specified queue. Long poll support is enabled by using the
     * WaitTimeSeconds parameter. For more information, see Amazon SQS Long Poll in the Amazon SQS Developer Guide.
     *

     *

     * Short poll is the default behavior where a weighted random set of
     * machines is sampled on a ReceiveMessage call. This means
     * only the messages on the sampled machines are returned. If the number of
     * messages in the queue is small (less than 1000), it is likely you will
     * get fewer messages than you requested per ReceiveMessage
     * call. If the number of messages in the queue is extremely small, you
     * might not receive any messages in a particular
     * ReceiveMessage response; in which case you should repeat the
     * request.
     *

     *

     * For each message returned, the response includes the following:
     *

     *

     *

     *

     * Message body
     *

     *

     *

     *

     * MD5 digest of the message body. For information about MD5, go to http://www.faqs.org/rfcs/rfc1321.html.
     *

     *

     *

     *

     * Message ID you received when you sent the message to the queue.
     *

     *

     *

     *

     * Receipt handle.
     *

     *

     *

     *

     * Message attributes.
     *

     *

     *

     *

     * MD5 digest of the message attributes.
     *

     *

     *

     *

     * The receipt handle is the identifier you must provide when deleting the
     * message. For more information, see Queue and Message Identifiers in the Amazon SQS Developer
     * Guide.
     *

     *

     * You can provide the VisibilityTimeout parameter in your
     * request, which will be applied to the messages that Amazon SQS returns in
     * the response. If you do not include the parameter, the overall visibility
     * timeout for the queue is used for the returned messages. For more
     * information, see Visibility Timeout in the Amazon SQS Developer Guide.
     *

     * <note>
     *

     * Going forward, new attributes might be added. If you are writing code
     * that calls this action, we recommend that you structure your code so that
     * it can handle new attributes gracefully.
     *

     * </note>
     *
     * @param receiveMessageRequest
     * @return A Java Future containing the result of the ReceiveMessage
     *         operation returned by the service.
     * @sample AmazonSQSAsync.ReceiveMessage
     */
    java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync(
            ReceiveMessageRequest receiveMessageRequest);

    /**
     *

     * Retrieves one or more messages, with a maximum limit of 10 messages, from
     * the specified queue. Long poll support is enabled by using the
     * WaitTimeSeconds parameter. For more information, see Amazon SQS Long Poll in the Amazon SQS Developer Guide.
     *

     *

     * Short poll is the default behavior where a weighted random set of
     * machines is sampled on a ReceiveMessage call. This means
     * only the messages on the sampled machines are returned. If the number of
     * messages in the queue is small (less than 1000), it is likely you will
     * get fewer messages than you requested per ReceiveMessage
     * call. If the number of messages in the queue is extremely small, you
     * might not receive any messages in a particular
     * ReceiveMessage response; in which case you should repeat the
     * request.
     *

     *

     * For each message returned, the response includes the following:
     *

     *

     *

     *

     * Message body
     *

     *

     *

     *

     * MD5 digest of the message body. For information about MD5, go to http://www.faqs.org/rfcs/rfc1321.html.
     *

     *

     *

     *

     * Message ID you received when you sent the message to the queue.
     *

     *

     *

     *

     * Receipt handle.
     *

     *

     *

     *

     * Message attributes.
     *

     *

     *

     *

     * MD5 digest of the message attributes.
     *

     *

     *

     *

     * The receipt handle is the identifier you must provide when deleting the
     * message. For more information, see Queue and Message Identifiers in the Amazon SQS Developer
     * Guide.
     *

     *

     * You can provide the VisibilityTimeout parameter in your
     * request, which will be applied to the messages that Amazon SQS returns in
     * the response. If you do not include the parameter, the overall visibility
     * timeout for the queue is used for the returned messages. For more
     * information, see Visibility Timeout in the Amazon SQS Developer Guide.
     *

     * <note>
     *

     * Going forward, new attributes might be added. If you are writing code
     * that calls this action, we recommend that you structure your code so that
     * it can handle new attributes gracefully.
     *

     * </note>
     *
     * @param receiveMessageRequest
     * @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 ReceiveMessage
     *         operation returned by the service.
     * @sample AmazonSQSAsyncHandler.ReceiveMessage
     */
    java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync(
            ReceiveMessageRequest receiveMessageRequest,
            com.amazonaws.handlers.AsyncHandler<ReceiveMessageRequest, ReceiveMessageResult> asyncHandler);

    /**
     * Simplified method form for invoking the ReceiveMessage operation.
     *
     * @see #receiveMessageAsync(ReceiveMessageRequest)
     */
    java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync(
            String queueUrl);

    /**
     * Simplified method form for invoking the ReceiveMessage operation with an
     * AsyncHandler.
     *
     * @see #receiveMessageAsync(ReceiveMessageRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync(
            String queueUrl,
            com.amazonaws.handlers.AsyncHandler<ReceiveMessageRequest, ReceiveMessageResult> asyncHandler);

    /**
     *

     * Revokes any permissions in the queue policy that matches the specified
     * Label parameter. Only the owner of the queue can remove
     * permissions.
     *

     *
     * @param removePermissionRequest
     * @sample AmazonSQSAsync.RemovePermission
     */
    java.util.concurrent.Future<Void> removePermissionAsync(
            RemovePermissionRequest removePermissionRequest);

    /**
     *

     * Revokes any permissions in the queue policy that matches the specified
     * Label parameter. Only the owner of the queue can remove
     * permissions.
     *

     *
     * @param removePermissionRequest
     * @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.
     * @sample AmazonSQSAsyncHandler.RemovePermission
     */
    java.util.concurrent.Future<Void> removePermissionAsync(
            RemovePermissionRequest removePermissionRequest,
            com.amazonaws.handlers.AsyncHandler<RemovePermissionRequest, Void> asyncHandler);

    /**
     * Simplified method form for invoking the RemovePermission operation.
     *
     * @see #removePermissionAsync(RemovePermissionRequest)
     */
    java.util.concurrent.Future<Void> removePermissionAsync(String queueUrl,
            String label);

    /**
     * Simplified method form for invoking the RemovePermission operation with
     * an AsyncHandler.
     *
     * @see #removePermissionAsync(RemovePermissionRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<Void> removePermissionAsync(
            String queueUrl,
            String label,
            com.amazonaws.handlers.AsyncHandler<RemovePermissionRequest, Void> asyncHandler);

    /**
     *

     * Delivers a message to the specified queue. With Amazon SQS, you now have
     * the ability to send large payload messages that are up to 256KB (262,144
     * bytes) in size. To send large payloads, you must use an AWS SDK that
     * supports SigV4 signing. To verify whether SigV4 is supported for an AWS
     * SDK, check the SDK release notes.
     *

     * <important>
     *

     * The following list shows the characters (in Unicode) allowed in your
     * message, according to the W3C XML specification. For more information, go
     * to http://www.w3.org/TR/REC
     * -xml/#charsets If you send any characters not included in the list,
     * your request will be rejected.
     *

     *

     * #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to
     * #x10FFFF]
     *

     * </important>
     *
     * @param sendMessageRequest
     * @return A Java Future containing the result of the SendMessage operation
     *         returned by the service.
     * @sample AmazonSQSAsync.SendMessage
     */
    java.util.concurrent.Future<SendMessageResult> sendMessageAsync(
            SendMessageRequest sendMessageRequest);

    /**
     *

     * Delivers a message to the specified queue. With Amazon SQS, you now have
     * the ability to send large payload messages that are up to 256KB (262,144
     * bytes) in size. To send large payloads, you must use an AWS SDK that
     * supports SigV4 signing. To verify whether SigV4 is supported for an AWS
     * SDK, check the SDK release notes.
     *

     * <important>
     *

     * The following list shows the characters (in Unicode) allowed in your
     * message, according to the W3C XML specification. For more information, go
     * to http://www.w3.org/TR/REC
     * -xml/#charsets If you send any characters not included in the list,
     * your request will be rejected.
     *

     *

     * #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to
     * #x10FFFF]
     *

     * </important>
     *
     * @param sendMessageRequest
     * @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 SendMessage operation
     *         returned by the service.
     * @sample AmazonSQSAsyncHandler.SendMessage
     */
    java.util.concurrent.Future<SendMessageResult> sendMessageAsync(
            SendMessageRequest sendMessageRequest,
            com.amazonaws.handlers.AsyncHandler<SendMessageRequest, SendMessageResult> asyncHandler);

    /**
     * Simplified method form for invoking the SendMessage operation.
     *
     * @see #sendMessageAsync(SendMessageRequest)
     */
    java.util.concurrent.Future<SendMessageResult> sendMessageAsync(
            String queueUrl, String messageBody);

    /**
     * Simplified method form for invoking the SendMessage operation with an
     * AsyncHandler.
     *
     * @see #sendMessageAsync(SendMessageRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<SendMessageResult> sendMessageAsync(
            String queueUrl,
            String messageBody,
            com.amazonaws.handlers.AsyncHandler<SendMessageRequest, SendMessageResult> asyncHandler);

    /**
     *

     * Delivers up to ten messages to the specified queue. This is a batch
     * version of SendMessage. The result of the send action on each
     * message is reported individually in the response. The maximum allowed
     * individual message size is 256 KB (262,144 bytes).
     *

     *

     * The maximum total payload size (i.e., the sum of all a batch's individual
     * message lengths) is also 256 KB (262,144 bytes).
     *

     *

     * If the DelaySeconds parameter is not specified for an entry,
     * the default for the queue is used.
     *

     * <important>The following list shows the characters (in Unicode) that are
     * allowed in your message, according to the W3C XML specification. For more
     * information, go to http://
     * www.faqs.org/rfcs/rfc1321.html. If you send any characters that are
     * not included in the list, your request will be rejected.
     *

     * #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to
     * #x10FFFF]
     *

     * </important> <important> Because the batch request can result in a
     * combination of successful and unsuccessful actions, you should check for
     * batch errors even when the call returns an HTTP status code of 200.
     * </important> <note>Some API actions take lists of parameters. These lists
     * are specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param sendMessageBatchRequest
     * @return A Java Future containing the result of the SendMessageBatch
     *         operation returned by the service.
     * @sample AmazonSQSAsync.SendMessageBatch
     */
    java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(
            SendMessageBatchRequest sendMessageBatchRequest);

    /**
     *

     * Delivers up to ten messages to the specified queue. This is a batch
     * version of SendMessage. The result of the send action on each
     * message is reported individually in the response. The maximum allowed
     * individual message size is 256 KB (262,144 bytes).
     *

     *

     * The maximum total payload size (i.e., the sum of all a batch's individual
     * message lengths) is also 256 KB (262,144 bytes).
     *

     *

     * If the DelaySeconds parameter is not specified for an entry,
     * the default for the queue is used.
     *

     * <important>The following list shows the characters (in Unicode) that are
     * allowed in your message, according to the W3C XML specification. For more
     * information, go to http://
     * www.faqs.org/rfcs/rfc1321.html. If you send any characters that are
     * not included in the list, your request will be rejected.
     *

     * #x9 | #xA | #xD | [#x20 to #xD7FF] | [#xE000 to #xFFFD] | [#x10000 to
     * #x10FFFF]
     *

     * </important> <important> Because the batch request can result in a
     * combination of successful and unsuccessful actions, you should check for
     * batch errors even when the call returns an HTTP status code of 200.
     * </important> <note>Some API actions take lists of parameters. These lists
     * are specified using the param.n notation. Values of
     * n are integers starting from 1. For example, a parameter
     * list with two elements looks like this: </note>
     *

     * <![CDATA[&Attribute.1=this]]>
     *

     *

     * <![CDATA[&Attribute.2=that]]>
     *

     *
     * @param sendMessageBatchRequest
     * @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 SendMessageBatch
     *         operation returned by the service.
     * @sample AmazonSQSAsyncHandler.SendMessageBatch
     */
    java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(
            SendMessageBatchRequest sendMessageBatchRequest,
            com.amazonaws.handlers.AsyncHandler<SendMessageBatchRequest, SendMessageBatchResult> asyncHandler);

    /**
     * Simplified method form for invoking the SendMessageBatch operation.
     *
     * @see #sendMessageBatchAsync(SendMessageBatchRequest)
     */
    java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(
            String queueUrl,
            java.util.List<SendMessageBatchRequestEntry> entries);

    /**
     * Simplified method form for invoking the SendMessageBatch operation with
     * an AsyncHandler.
     *
     * @see #sendMessageBatchAsync(SendMessageBatchRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(
            String queueUrl,
            java.util.List<SendMessageBatchRequestEntry> entries,
            com.amazonaws.handlers.AsyncHandler<SendMessageBatchRequest, SendMessageBatchResult> asyncHandler);

    /**
     *

     * Sets the value of one or more queue attributes. When you change a queue's
     * attributes, the change can take up to 60 seconds for most of the
     * attributes to propagate throughout the SQS system. Changes made to the
     * MessageRetentionPeriod attribute can take up to 15 minutes.
     *

     * <note>Going forward, new attributes might be added. If you are writing
     * code that calls this action, we recommend that you structure your code so
     * that it can handle new attributes gracefully.</note>
     *
     * @param setQueueAttributesRequest
     * @sample AmazonSQSAsync.SetQueueAttributes
     */
    java.util.concurrent.Future<Void> setQueueAttributesAsync(
            SetQueueAttributesRequest setQueueAttributesRequest);

    /**
     *

     * Sets the value of one or more queue attributes. When you change a queue's
     * attributes, the change can take up to 60 seconds for most of the
     * attributes to propagate throughout the SQS system. Changes made to the
     * MessageRetentionPeriod attribute can take up to 15 minutes.
     *

     * <note>Going forward, new attributes might be added. If you are writing
     * code that calls this action, we recommend that you structure your code so
     * that it can handle new attributes gracefully.</note>
     *
     * @param setQueueAttributesRequest
     * @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.
     * @sample AmazonSQSAsyncHandler.SetQueueAttributes
     */
    java.util.concurrent.Future<Void> setQueueAttributesAsync(
            SetQueueAttributesRequest setQueueAttributesRequest,
            com.amazonaws.handlers.AsyncHandler<SetQueueAttributesRequest, Void> asyncHandler);

    /**
     * Simplified method form for invoking the SetQueueAttributes operation.
     *
     * @see #setQueueAttributesAsync(SetQueueAttributesRequest)
     */
    java.util.concurrent.Future<Void> setQueueAttributesAsync(String queueUrl,
            java.util.Map<String, String> attributes);

    /**
     * Simplified method form for invoking the SetQueueAttributes operation with
     * an AsyncHandler.
     *
     * @see #setQueueAttributesAsync(SetQueueAttributesRequest,
     *      com.amazonaws.handlers.AsyncHandler)
     */
    java.util.concurrent.Future<Void> setQueueAttributesAsync(
            String queueUrl,
            java.util.Map<String, String> attributes,
            com.amazonaws.handlers.AsyncHandler<SetQueueAttributesRequest, Void> asyncHandler);

}