api.go

// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.

// Package sqs provides a client for Amazon Simple Queue Service.
package sqs

import (
	"sync"

	"github.com/aws/aws-sdk-go/aws"
)

var oprw sync.Mutex

// AddPermissionRequest generates a request for the AddPermission operation.
func (c *SQS) AddPermissionRequest(input *AddPermissionInput) (req *aws.Request, output *AddPermissionOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opAddPermission == nil {
		opAddPermission = &aws.Operation{
			Name:       "AddPermission",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &AddPermissionInput{}
	}

	req = c.newRequest(opAddPermission, input, output)
	output = &AddPermissionOutput{}
	req.Data = output
	return
}

// Adds a permission to a queue for a specific principal (http://docs.aws.amazon.com/general/latest/gr/glos-chap.html#P).
// 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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html)
// in the Amazon SQS Developer Guide.
//
//  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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AccessPolicyLanguage.html)
// in the Amazon SQS Developer Guide.
//
//  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:  &Attribute.1=this
//
// &Attribute.2=that
func (c *SQS) AddPermission(input *AddPermissionInput) (*AddPermissionOutput, error) {
	req, out := c.AddPermissionRequest(input)
	err := req.Send()
	return out, err
}

var opAddPermission *aws.Operation

// ChangeMessageVisibilityRequest generates a request for the ChangeMessageVisibility operation.
func (c *SQS) ChangeMessageVisibilityRequest(input *ChangeMessageVisibilityInput) (req *aws.Request, output *ChangeMessageVisibilityOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opChangeMessageVisibility == nil {
		opChangeMessageVisibility = &aws.Operation{
			Name:       "ChangeMessageVisibility",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &ChangeMessageVisibilityInput{}
	}

	req = c.newRequest(opChangeMessageVisibility, input, output)
	output = &ChangeMessageVisibilityOutput{}
	req.Data = output
	return
}

// 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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
// in the Amazon SQS Developer Guide.)
//
// For example, let's say you have a message and its default message visibility
// timeout is 30 minutes. You could call ChangeMessageVisiblity with a value
// of two hours and the effective timeout would be two hours and 30 minutes.
// When that time comes near you could again extend the time out by calling
// ChangeMessageVisiblity, but this time the maximum allowed timeout would be
// 9 hours and 30 minutes.
//
// 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.
//
// 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. 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.
func (c *SQS) ChangeMessageVisibility(input *ChangeMessageVisibilityInput) (*ChangeMessageVisibilityOutput, error) {
	req, out := c.ChangeMessageVisibilityRequest(input)
	err := req.Send()
	return out, err
}

var opChangeMessageVisibility *aws.Operation

// ChangeMessageVisibilityBatchRequest generates a request for the ChangeMessageVisibilityBatch operation.
func (c *SQS) ChangeMessageVisibilityBatchRequest(input *ChangeMessageVisibilityBatchInput) (req *aws.Request, output *ChangeMessageVisibilityBatchOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opChangeMessageVisibilityBatch == nil {
		opChangeMessageVisibilityBatch = &aws.Operation{
			Name:       "ChangeMessageVisibilityBatch",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &ChangeMessageVisibilityBatchInput{}
	}

	req = c.newRequest(opChangeMessageVisibilityBatch, input, output)
	output = &ChangeMessageVisibilityBatchOutput{}
	req.Data = output
	return
}

// 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.
//
// 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. 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:  &Attribute.1=this
//
// &Attribute.2=that
func (c *SQS) ChangeMessageVisibilityBatch(input *ChangeMessageVisibilityBatchInput) (*ChangeMessageVisibilityBatchOutput, error) {
	req, out := c.ChangeMessageVisibilityBatchRequest(input)
	err := req.Send()
	return out, err
}

var opChangeMessageVisibilityBatch *aws.Operation

// CreateQueueRequest generates a request for the CreateQueue operation.
func (c *SQS) CreateQueueRequest(input *CreateQueueInput) (req *aws.Request, output *CreateQueueOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opCreateQueue == nil {
		opCreateQueue = &aws.Operation{
			Name:       "CreateQueue",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &CreateQueueInput{}
	}

	req = c.newRequest(opCreateQueue, input, output)
	output = &CreateQueueOutput{}
	req.Data = output
	return
}

// 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.
//
//  If you delete a queue, you must wait at least 60 seconds before creating
// a queue with the same name.
//
//  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.
//
// Use GetQueueUrl to get a queue's URL. GetQueueUrl requires only the QueueName
// parameter.
//
// 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.
//
// 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:  &Attribute.1=this
//
// &Attribute.2=that
func (c *SQS) CreateQueue(input *CreateQueueInput) (*CreateQueueOutput, error) {
	req, out := c.CreateQueueRequest(input)
	err := req.Send()
	return out, err
}

var opCreateQueue *aws.Operation

// DeleteMessageRequest generates a request for the DeleteMessage operation.
func (c *SQS) DeleteMessageRequest(input *DeleteMessageInput) (req *aws.Request, output *DeleteMessageOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDeleteMessage == nil {
		opDeleteMessage = &aws.Operation{
			Name:       "DeleteMessage",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &DeleteMessageInput{}
	}

	req = c.newRequest(opDeleteMessage, input, output)
	output = &DeleteMessageOutput{}
	req.Data = output
	return
}

// 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.
//
//   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.
//
//    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.
func (c *SQS) DeleteMessage(input *DeleteMessageInput) (*DeleteMessageOutput, error) {
	req, out := c.DeleteMessageRequest(input)
	err := req.Send()
	return out, err
}

var opDeleteMessage *aws.Operation

// DeleteMessageBatchRequest generates a request for the DeleteMessageBatch operation.
func (c *SQS) DeleteMessageBatchRequest(input *DeleteMessageBatchInput) (req *aws.Request, output *DeleteMessageBatchOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDeleteMessageBatch == nil {
		opDeleteMessageBatch = &aws.Operation{
			Name:       "DeleteMessageBatch",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &DeleteMessageBatchInput{}
	}

	req = c.newRequest(opDeleteMessageBatch, input, output)
	output = &DeleteMessageBatchOutput{}
	req.Data = output
	return
}

// 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.
//
//   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.
//
//  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:  &Attribute.1=this
//
// &Attribute.2=that
func (c *SQS) DeleteMessageBatch(input *DeleteMessageBatchInput) (*DeleteMessageBatchOutput, error) {
	req, out := c.DeleteMessageBatchRequest(input)
	err := req.Send()
	return out, err
}

var opDeleteMessageBatch *aws.Operation

// DeleteQueueRequest generates a request for the DeleteQueue operation.
func (c *SQS) DeleteQueueRequest(input *DeleteQueueInput) (req *aws.Request, output *DeleteQueueOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opDeleteQueue == nil {
		opDeleteQueue = &aws.Operation{
			Name:       "DeleteQueue",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &DeleteQueueInput{}
	}

	req = c.newRequest(opDeleteQueue, input, output)
	output = &DeleteQueueOutput{}
	req.Data = output
	return
}

// 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.
//
//   Use DeleteQueue with care; once you delete your queue, any messages in
// the queue are no longer available.
//
//   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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSConcepts.html)
// in the Amazon SQS Developer Guide.
func (c *SQS) DeleteQueue(input *DeleteQueueInput) (*DeleteQueueOutput, error) {
	req, out := c.DeleteQueueRequest(input)
	err := req.Send()
	return out, err
}

var opDeleteQueue *aws.Operation

// GetQueueAttributesRequest generates a request for the GetQueueAttributes operation.
func (c *SQS) GetQueueAttributesRequest(input *GetQueueAttributesInput) (req *aws.Request, output *GetQueueAttributesOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opGetQueueAttributes == nil {
		opGetQueueAttributes = &aws.Operation{
			Name:       "GetQueueAttributes",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &GetQueueAttributesInput{}
	}

	req = c.newRequest(opGetQueueAttributes, input, output)
	output = &GetQueueAttributesOutput{}
	req.Data = output
	return
}

// 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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html)
// 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
// (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ApproximateNumber.html)
// in the Amazon SQS Developer Guide.  VisibilityTimeout - returns the visibility
// timeout for the queue. For more information about visibility timeout, see
// Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
// 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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html)
// in the Amazon SQS Developer Guide.
//
// 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. 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:  &Attribute.1=this
//
// &Attribute.2=that
func (c *SQS) GetQueueAttributes(input *GetQueueAttributesInput) (*GetQueueAttributesOutput, error) {
	req, out := c.GetQueueAttributesRequest(input)
	err := req.Send()
	return out, err
}

var opGetQueueAttributes *aws.Operation

// GetQueueURLRequest generates a request for the GetQueueURL operation.
func (c *SQS) GetQueueURLRequest(input *GetQueueURLInput) (req *aws.Request, output *GetQueueURLOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opGetQueueURL == nil {
		opGetQueueURL = &aws.Operation{
			Name:       "GetQueueUrl",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &GetQueueURLInput{}
	}

	req = c.newRequest(opGetQueueURL, input, output)
	output = &GetQueueURLOutput{}
	req.Data = output
	return
}

// 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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html)
// in the Amazon SQS Developer Guide.
func (c *SQS) GetQueueURL(input *GetQueueURLInput) (*GetQueueURLOutput, error) {
	req, out := c.GetQueueURLRequest(input)
	err := req.Send()
	return out, err
}

var opGetQueueURL *aws.Operation

// ListDeadLetterSourceQueuesRequest generates a request for the ListDeadLetterSourceQueues operation.
func (c *SQS) ListDeadLetterSourceQueuesRequest(input *ListDeadLetterSourceQueuesInput) (req *aws.Request, output *ListDeadLetterSourceQueuesOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opListDeadLetterSourceQueues == nil {
		opListDeadLetterSourceQueues = &aws.Operation{
			Name:       "ListDeadLetterSourceQueues",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &ListDeadLetterSourceQueuesInput{}
	}

	req = c.newRequest(opListDeadLetterSourceQueues, input, output)
	output = &ListDeadLetterSourceQueuesOutput{}
	req.Data = output
	return
}

// 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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSDeadLetterQueue.html).
func (c *SQS) ListDeadLetterSourceQueues(input *ListDeadLetterSourceQueuesInput) (*ListDeadLetterSourceQueuesOutput, error) {
	req, out := c.ListDeadLetterSourceQueuesRequest(input)
	err := req.Send()
	return out, err
}

var opListDeadLetterSourceQueues *aws.Operation

// ListQueuesRequest generates a request for the ListQueues operation.
func (c *SQS) ListQueuesRequest(input *ListQueuesInput) (req *aws.Request, output *ListQueuesOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opListQueues == nil {
		opListQueues = &aws.Operation{
			Name:       "ListQueues",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &ListQueuesInput{}
	}

	req = c.newRequest(opListQueues, input, output)
	output = &ListQueuesOutput{}
	req.Data = output
	return
}

// 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.
func (c *SQS) ListQueues(input *ListQueuesInput) (*ListQueuesOutput, error) {
	req, out := c.ListQueuesRequest(input)
	err := req.Send()
	return out, err
}

var opListQueues *aws.Operation

// PurgeQueueRequest generates a request for the PurgeQueue operation.
func (c *SQS) PurgeQueueRequest(input *PurgeQueueInput) (req *aws.Request, output *PurgeQueueOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opPurgeQueue == nil {
		opPurgeQueue = &aws.Operation{
			Name:       "PurgeQueue",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &PurgeQueueInput{}
	}

	req = c.newRequest(opPurgeQueue, input, output)
	output = &PurgeQueueOutput{}
	req.Data = output
	return
}

// Deletes the messages in a queue specified by the queue URL.
//
// When you use the PurgeQueue API, the deleted messages in the queue cannot
// be retrieved. 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.
func (c *SQS) PurgeQueue(input *PurgeQueueInput) (*PurgeQueueOutput, error) {
	req, out := c.PurgeQueueRequest(input)
	err := req.Send()
	return out, err
}

var opPurgeQueue *aws.Operation

// ReceiveMessageRequest generates a request for the ReceiveMessage operation.
func (c *SQS) ReceiveMessageRequest(input *ReceiveMessageInput) (req *aws.Request, output *ReceiveMessageOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opReceiveMessage == nil {
		opReceiveMessage = &aws.Operation{
			Name:       "ReceiveMessage",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &ReceiveMessageInput{}
	}

	req = c.newRequest(opReceiveMessage, input, output)
	output = &ReceiveMessageOutput{}
	req.Data = output
	return
}

// 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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html)
// 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
// (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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ImportantIdentifiers.html)
// 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 (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
// in the Amazon SQS Developer Guide.
//
//   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.
func (c *SQS) ReceiveMessage(input *ReceiveMessageInput) (*ReceiveMessageOutput, error) {
	req, out := c.ReceiveMessageRequest(input)
	err := req.Send()
	return out, err
}

var opReceiveMessage *aws.Operation

// RemovePermissionRequest generates a request for the RemovePermission operation.
func (c *SQS) RemovePermissionRequest(input *RemovePermissionInput) (req *aws.Request, output *RemovePermissionOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opRemovePermission == nil {
		opRemovePermission = &aws.Operation{
			Name:       "RemovePermission",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &RemovePermissionInput{}
	}

	req = c.newRequest(opRemovePermission, input, output)
	output = &RemovePermissionOutput{}
	req.Data = output
	return
}

// Revokes any permissions in the queue policy that matches the specified Label
// parameter. Only the owner of the queue can remove permissions.
func (c *SQS) RemovePermission(input *RemovePermissionInput) (*RemovePermissionOutput, error) {
	req, out := c.RemovePermissionRequest(input)
	err := req.Send()
	return out, err
}

var opRemovePermission *aws.Operation

// SendMessageRequest generates a request for the SendMessage operation.
func (c *SQS) SendMessageRequest(input *SendMessageInput) (req *aws.Request, output *SendMessageOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opSendMessage == nil {
		opSendMessage = &aws.Operation{
			Name:       "SendMessage",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &SendMessageInput{}
	}

	req = c.newRequest(opSendMessage, input, output)
	output = &SendMessageOutput{}
	req.Data = output
	return
}

// 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.
//
//   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
// (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]
func (c *SQS) SendMessage(input *SendMessageInput) (*SendMessageOutput, error) {
	req, out := c.SendMessageRequest(input)
	err := req.Send()
	return out, err
}

var opSendMessage *aws.Operation

// SendMessageBatchRequest generates a request for the SendMessageBatch operation.
func (c *SQS) SendMessageBatchRequest(input *SendMessageBatchInput) (req *aws.Request, output *SendMessageBatchOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opSendMessageBatch == nil {
		opSendMessageBatch = &aws.Operation{
			Name:       "SendMessageBatch",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &SendMessageBatchInput{}
	}

	req = c.newRequest(opSendMessageBatch, input, output)
	output = &SendMessageBatchOutput{}
	req.Data = output
	return
}

// 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.
//
// 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 (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]
//
//   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.  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:  &Attribute.1=this
//
// &Attribute.2=that
func (c *SQS) SendMessageBatch(input *SendMessageBatchInput) (*SendMessageBatchOutput, error) {
	req, out := c.SendMessageBatchRequest(input)
	err := req.Send()
	return out, err
}

var opSendMessageBatch *aws.Operation

// SetQueueAttributesRequest generates a request for the SetQueueAttributes operation.
func (c *SQS) SetQueueAttributesRequest(input *SetQueueAttributesInput) (req *aws.Request, output *SetQueueAttributesOutput) {
	oprw.Lock()
	defer oprw.Unlock()

	if opSetQueueAttributes == nil {
		opSetQueueAttributes = &aws.Operation{
			Name:       "SetQueueAttributes",
			HTTPMethod: "POST",
			HTTPPath:   "/",
		}
	}

	if input == nil {
		input = &SetQueueAttributesInput{}
	}

	req = c.newRequest(opSetQueueAttributes, input, output)
	output = &SetQueueAttributesOutput{}
	req.Data = output
	return
}

// 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.
//
// 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.
func (c *SQS) SetQueueAttributes(input *SetQueueAttributesInput) (*SetQueueAttributesOutput, error) {
	req, out := c.SetQueueAttributesRequest(input)
	err := req.Send()
	return out, err
}

var opSetQueueAttributes *aws.Operation

type AddPermissionInput struct {
	// The AWS account number of the principal (http://docs.aws.amazon.com/general/latest/gr/glos-chap.html#P)
	// who will be given permission. The principal must have an AWS account, but
	// does not need to be signed up for Amazon SQS. For information about locating
	// the AWS account identification, see Your AWS Identifiers (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AWSCredentials.html)
	// in the Amazon SQS Developer Guide.
	AWSAccountIDs []*string `locationName:"AWSAccountIds" locationNameList:"AWSAccountId" type:"list" flattened:"true" required:"true"`

	// The action the client wants to allow for the specified principal. The following
	// are valid values: * | SendMessage | ReceiveMessage | DeleteMessage | ChangeMessageVisibility
	// | GetQueueAttributes | GetQueueUrl. For more information about these actions,
	// see Understanding Permissions (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/acp-overview.html#PermissionTypes)
	// in the Amazon SQS Developer Guide.
	//
	// Specifying SendMessage, DeleteMessage, or ChangeMessageVisibility for the
	// ActionName.n also grants permissions for the corresponding batch versions
	// of those actions: SendMessageBatch, DeleteMessageBatch, and ChangeMessageVisibilityBatch.
	Actions []*string `locationNameList:"ActionName" type:"list" flattened:"true" required:"true"`

	// The unique identification of the permission you're setting (e.g., AliceSendMessage).
	// Constraints: Maximum 80 characters; alphanumeric characters, hyphens (-),
	// and underscores (_) are allowed.
	Label *string `type:"string" required:"true"`

	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataAddPermissionInput `json:"-" xml:"-"`
}

type metadataAddPermissionInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type AddPermissionOutput struct {
	metadataAddPermissionOutput `json:"-" xml:"-"`
}

type metadataAddPermissionOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// This is used in the responses of batch API to give a detailed description
// of the result of an action on each entry in the request.
type BatchResultErrorEntry struct {
	// An error code representing why the action failed on this entry.
	Code *string `type:"string" required:"true"`

	// The id of an entry in a batch request.
	ID *string `locationName:"Id" type:"string" required:"true"`

	// A message explaining why the action failed on this entry.
	Message *string `type:"string"`

	// Whether the error happened due to the sender's fault.
	SenderFault *bool `type:"boolean" required:"true"`

	metadataBatchResultErrorEntry `json:"-" xml:"-"`
}

type metadataBatchResultErrorEntry struct {
	SDKShapeTraits bool `type:"structure"`
}

type ChangeMessageVisibilityBatchInput struct {
	// A list of receipt handles of the messages for which the visibility timeout
	// must be changed.
	Entries []*ChangeMessageVisibilityBatchRequestEntry `locationNameList:"ChangeMessageVisibilityBatchRequestEntry" type:"list" flattened:"true" required:"true"`

	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataChangeMessageVisibilityBatchInput `json:"-" xml:"-"`
}

type metadataChangeMessageVisibilityBatchInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// For each message in the batch, the response contains a ChangeMessageVisibilityBatchResultEntry
// tag if the message succeeds or a BatchResultErrorEntry tag if the message
// fails.
type ChangeMessageVisibilityBatchOutput struct {
	// A list of BatchResultErrorEntry items.
	Failed []*BatchResultErrorEntry `locationNameList:"BatchResultErrorEntry" type:"list" flattened:"true" required:"true"`

	// A list of ChangeMessageVisibilityBatchResultEntry items.
	Successful []*ChangeMessageVisibilityBatchResultEntry `locationNameList:"ChangeMessageVisibilityBatchResultEntry" type:"list" flattened:"true" required:"true"`

	metadataChangeMessageVisibilityBatchOutput `json:"-" xml:"-"`
}

type metadataChangeMessageVisibilityBatchOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Encloses a receipt handle and an entry id for each message in ChangeMessageVisibilityBatch.
//
//  All of the following parameters are list parameters that must be prefixed
// with ChangeMessageVisibilityBatchRequestEntry.n, where n is an integer value
// starting with 1. For example, a parameter list for this action might look
// like this:
//
//  &ChangeMessageVisibilityBatchRequestEntry.1.Id=change_visibility_msg_2
//
// &ChangeMessageVisibilityBatchRequestEntry.1.ReceiptHandle=Your_Receipt_Handle
//
// &ChangeMessageVisibilityBatchRequestEntry.1.VisibilityTimeout=45
type ChangeMessageVisibilityBatchRequestEntry struct {
	// An identifier for this particular receipt handle. This is used to communicate
	// the result. Note that the Ids of a batch request need to be unique within
	// the request.
	ID *string `locationName:"Id" type:"string" required:"true"`

	// A receipt handle.
	ReceiptHandle *string `type:"string" required:"true"`

	// The new value (in seconds) for the message's visibility timeout.
	VisibilityTimeout *int64 `type:"integer"`

	metadataChangeMessageVisibilityBatchRequestEntry `json:"-" xml:"-"`
}

type metadataChangeMessageVisibilityBatchRequestEntry struct {
	SDKShapeTraits bool `type:"structure"`
}

// Encloses the id of an entry in ChangeMessageVisibilityBatch.
type ChangeMessageVisibilityBatchResultEntry struct {
	// Represents a message whose visibility timeout has been changed successfully.
	ID *string `locationName:"Id" type:"string" required:"true"`

	metadataChangeMessageVisibilityBatchResultEntry `json:"-" xml:"-"`
}

type metadataChangeMessageVisibilityBatchResultEntry struct {
	SDKShapeTraits bool `type:"structure"`
}

type ChangeMessageVisibilityInput struct {
	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	// The receipt handle associated with the message whose visibility timeout should
	// be changed. This parameter is returned by the ReceiveMessage action.
	ReceiptHandle *string `type:"string" required:"true"`

	// The new value (in seconds - from 0 to 43200 - maximum 12 hours) for the message's
	// visibility timeout.
	VisibilityTimeout *int64 `type:"integer" required:"true"`

	metadataChangeMessageVisibilityInput `json:"-" xml:"-"`
}

type metadataChangeMessageVisibilityInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type ChangeMessageVisibilityOutput struct {
	metadataChangeMessageVisibilityOutput `json:"-" xml:"-"`
}

type metadataChangeMessageVisibilityOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type CreateQueueInput struct {
	// A map of attributes with their corresponding values.
	//
	// The following lists the names, descriptions, and values of the special request
	// parameters the CreateQueue action uses:
	//
	//    DelaySeconds - The time in seconds that the delivery of all messages
	// in the queue will be delayed. An integer from 0 to 900 (15 minutes). The
	// default for this attribute is 0 (zero).  MaximumMessageSize - The limit of
	// how many bytes a message can contain before Amazon SQS rejects it. An integer
	// from 1024 bytes (1 KiB) up to 262144 bytes (256 KiB). The default for this
	// attribute is 262144 (256 KiB).  MessageRetentionPeriod - The number of seconds
	// Amazon SQS retains a message. Integer representing seconds, from 60 (1 minute)
	// to 1209600 (14 days). The default for this attribute is 345600 (4 days).
	//  Policy - The queue's policy. A valid AWS policy. For more information about
	// policy structure, see Overview of AWS IAM Policies (http://docs.aws.amazon.com/IAM/latest/UserGuide/PoliciesOverview.html)
	// in the Amazon IAM User Guide.  ReceiveMessageWaitTimeSeconds - The time for
	// which a ReceiveMessage call will wait for a message to arrive. An integer
	// from 0 to 20 (seconds). The default for this attribute is 0.   VisibilityTimeout
	// - The visibility timeout for the queue. An integer from 0 to 43200 (12 hours).
	// The default for this attribute is 30. For more information about visibility
	// timeout, see Visibility Timeout (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/AboutVT.html)
	// in the Amazon SQS Developer Guide.
	Attributes map[string]*string `locationName:"Attribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`

	// The name for the queue to be created.
	QueueName *string `type:"string" required:"true"`

	metadataCreateQueueInput `json:"-" xml:"-"`
}

type metadataCreateQueueInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Returns the QueueUrl element of the created queue.
type CreateQueueOutput struct {
	// The URL for the created Amazon SQS queue.
	QueueURL *string `locationName:"QueueUrl" type:"string"`

	metadataCreateQueueOutput `json:"-" xml:"-"`
}

type metadataCreateQueueOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type DeleteMessageBatchInput struct {
	// A list of receipt handles for the messages to be deleted.
	Entries []*DeleteMessageBatchRequestEntry `locationNameList:"DeleteMessageBatchRequestEntry" type:"list" flattened:"true" required:"true"`

	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataDeleteMessageBatchInput `json:"-" xml:"-"`
}

type metadataDeleteMessageBatchInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// For each message in the batch, the response contains a DeleteMessageBatchResultEntry
// tag if the message is deleted or a BatchResultErrorEntry tag if the message
// cannot be deleted.
type DeleteMessageBatchOutput struct {
	// A list of BatchResultErrorEntry items.
	Failed []*BatchResultErrorEntry `locationNameList:"BatchResultErrorEntry" type:"list" flattened:"true" required:"true"`

	// A list of DeleteMessageBatchResultEntry items.
	Successful []*DeleteMessageBatchResultEntry `locationNameList:"DeleteMessageBatchResultEntry" type:"list" flattened:"true" required:"true"`

	metadataDeleteMessageBatchOutput `json:"-" xml:"-"`
}

type metadataDeleteMessageBatchOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Encloses a receipt handle and an identifier for it.
type DeleteMessageBatchRequestEntry struct {
	// An identifier for this particular receipt handle. This is used to communicate
	// the result. Note that the Ids of a batch request need to be unique within
	// the request.
	ID *string `locationName:"Id" type:"string" required:"true"`

	// A receipt handle.
	ReceiptHandle *string `type:"string" required:"true"`

	metadataDeleteMessageBatchRequestEntry `json:"-" xml:"-"`
}

type metadataDeleteMessageBatchRequestEntry struct {
	SDKShapeTraits bool `type:"structure"`
}

// Encloses the id an entry in DeleteMessageBatch.
type DeleteMessageBatchResultEntry struct {
	// Represents a successfully deleted message.
	ID *string `locationName:"Id" type:"string" required:"true"`

	metadataDeleteMessageBatchResultEntry `json:"-" xml:"-"`
}

type metadataDeleteMessageBatchResultEntry struct {
	SDKShapeTraits bool `type:"structure"`
}

type DeleteMessageInput struct {
	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	// The receipt handle associated with the message to delete.
	ReceiptHandle *string `type:"string" required:"true"`

	metadataDeleteMessageInput `json:"-" xml:"-"`
}

type metadataDeleteMessageInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type DeleteMessageOutput struct {
	metadataDeleteMessageOutput `json:"-" xml:"-"`
}

type metadataDeleteMessageOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type DeleteQueueInput struct {
	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataDeleteQueueInput `json:"-" xml:"-"`
}

type metadataDeleteQueueInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type DeleteQueueOutput struct {
	metadataDeleteQueueOutput `json:"-" xml:"-"`
}

type metadataDeleteQueueOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type GetQueueAttributesInput struct {
	// A list of attributes to retrieve information for.
	AttributeNames []*string `locationNameList:"AttributeName" type:"list" flattened:"true"`

	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataGetQueueAttributesInput `json:"-" xml:"-"`
}

type metadataGetQueueAttributesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// A list of returned queue attributes.
type GetQueueAttributesOutput struct {
	// A map of attributes to the respective values.
	Attributes map[string]*string `locationName:"Attribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`

	metadataGetQueueAttributesOutput `json:"-" xml:"-"`
}

type metadataGetQueueAttributesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type GetQueueURLInput struct {
	// The name of the queue whose URL must be fetched. Maximum 80 characters; alphanumeric
	// characters, hyphens (-), and underscores (_) are allowed.
	QueueName *string `type:"string" required:"true"`

	// The AWS account ID of the account that created the queue.
	QueueOwnerAWSAccountID *string `locationName:"QueueOwnerAWSAccountId" type:"string"`

	metadataGetQueueURLInput `json:"-" xml:"-"`
}

type metadataGetQueueURLInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// For more information, see Responses (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/UnderstandingResponses.html)
// in the Amazon SQS Developer Guide.
type GetQueueURLOutput struct {
	// The URL for the queue.
	QueueURL *string `locationName:"QueueUrl" type:"string"`

	metadataGetQueueURLOutput `json:"-" xml:"-"`
}

type metadataGetQueueURLOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type ListDeadLetterSourceQueuesInput struct {
	// The queue URL of a dead letter queue.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataListDeadLetterSourceQueuesInput `json:"-" xml:"-"`
}

type metadataListDeadLetterSourceQueuesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// A list of your dead letter source queues.
type ListDeadLetterSourceQueuesOutput struct {
	// A list of source queue URLs that have the RedrivePolicy queue attribute configured
	// with a dead letter queue.
	QueueURLs []*string `locationName:"queueUrls" locationNameList:"QueueUrl" type:"list" flattened:"true" required:"true"`

	metadataListDeadLetterSourceQueuesOutput `json:"-" xml:"-"`
}

type metadataListDeadLetterSourceQueuesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type ListQueuesInput struct {
	// A string to use for filtering the list results. Only those queues whose name
	// begins with the specified string are returned.
	QueueNamePrefix *string `type:"string"`

	metadataListQueuesInput `json:"-" xml:"-"`
}

type metadataListQueuesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// A list of your queues.
type ListQueuesOutput struct {
	// A list of queue URLs, up to 1000 entries.
	QueueURLs []*string `locationName:"QueueUrls" locationNameList:"QueueUrl" type:"list" flattened:"true"`

	metadataListQueuesOutput `json:"-" xml:"-"`
}

type metadataListQueuesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// An Amazon SQS message.
type Message struct {
	// SenderId, SentTimestamp, ApproximateReceiveCount, and/or ApproximateFirstReceiveTimestamp.
	// SentTimestamp and ApproximateFirstReceiveTimestamp are each returned as an
	// integer representing the epoch time (http://en.wikipedia.org/wiki/Unix_time)
	// in milliseconds.
	Attributes map[string]*string `locationName:"Attribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`

	// The message's contents (not URL-encoded).
	Body *string `type:"string"`

	// An MD5 digest of the non-URL-encoded message body string.
	MD5OfBody *string `type:"string"`

	// An MD5 digest of the non-URL-encoded message attribute string. This can be
	// used to verify that Amazon SQS received the message correctly. Amazon SQS
	// first URL decodes the message before creating the MD5 digest. For information
	// about MD5, go to http://www.faqs.org/rfcs/rfc1321.html (http://www.faqs.org/rfcs/rfc1321.html).
	MD5OfMessageAttributes *string `type:"string"`

	// Each message attribute consists of a Name, Type, and Value. For more information,
	// see Message Attribute Items (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSMessageAttributes.html#SQSMessageAttributesNTV).
	MessageAttributes map[string]*MessageAttributeValue `locationName:"MessageAttribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`

	// A unique identifier for the message. Message IDs are considered unique across
	// all AWS accounts for an extended period of time.
	MessageID *string `locationName:"MessageId" type:"string"`

	// An identifier associated with the act of receiving the message. A new receipt
	// handle is returned every time you receive a message. When deleting a message,
	// you provide the last received receipt handle to delete the message.
	ReceiptHandle *string `type:"string"`

	metadataMessage `json:"-" xml:"-"`
}

type metadataMessage struct {
	SDKShapeTraits bool `type:"structure"`
}

// The user-specified message attribute value. For string data types, the value
// attribute has the same restrictions on the content as the message body. For
// more information, see SendMessage (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html).
//
// Name, type, and value must not be empty or null. In addition, the message
// body should not be empty or null. All parts of the message attribute, including
// name, type, and value, are included in the message size restriction, which
// is currently 256 KB (262,144 bytes).
type MessageAttributeValue struct {
	// Not implemented. Reserved for future use.
	BinaryListValues [][]byte `locationName:"BinaryListValue" locationNameList:"BinaryListValue" type:"list" flattened:"true"`

	// Binary type attributes can store any binary data, for example, compressed
	// data, encrypted data, or images.
	BinaryValue []byte `type:"blob"`

	// Amazon SQS supports the following logical data types: String, Number, and
	// Binary. In addition, you can append your own custom labels. For more information,
	// see Message Attribute Data Types (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSMessageAttributes.html#SQSMessageAttributes.DataTypes).
	DataType *string `type:"string" required:"true"`

	// Not implemented. Reserved for future use.
	StringListValues []*string `locationName:"StringListValue" locationNameList:"StringListValue" type:"list" flattened:"true"`

	// Strings are Unicode with UTF8 binary encoding. For a list of code values,
	// see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters (http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters).
	StringValue *string `type:"string"`

	metadataMessageAttributeValue `json:"-" xml:"-"`
}

type metadataMessageAttributeValue struct {
	SDKShapeTraits bool `type:"structure"`
}

type PurgeQueueInput struct {
	// The queue URL of the queue to delete the messages from when using the PurgeQueue
	// API.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataPurgeQueueInput `json:"-" xml:"-"`
}

type metadataPurgeQueueInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type PurgeQueueOutput struct {
	metadataPurgeQueueOutput `json:"-" xml:"-"`
}

type metadataPurgeQueueOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type ReceiveMessageInput struct {
	// A list of attributes that need to be returned along with each message.
	//
	//  The following lists the names and descriptions of the attributes that can
	// be returned:
	//
	//   All - returns all values.  ApproximateFirstReceiveTimestamp - returns
	// the time when the message was first received from the queue (epoch time in
	// milliseconds).  ApproximateReceiveCount - returns the number of times a message
	// has been received from the queue but not deleted.  SenderId - returns the
	// AWS account number (or the IP address, if anonymous access is allowed) of
	// the sender.  SentTimestamp - returns the time when the message was sent to
	// the queue (epoch time in milliseconds).
	AttributeNames []*string `locationNameList:"AttributeName" type:"list" flattened:"true"`

	// The maximum number of messages to return. Amazon SQS never returns more messages
	// than this value but may return fewer. Values can be from 1 to 10. Default
	// is 1.
	//
	// All of the messages are not necessarily returned.
	MaxNumberOfMessages *int64 `type:"integer"`

	// The name of the message attribute, where N is the index. The message attribute
	// name can contain the following characters: A-Z, a-z, 0-9, underscore (_),
	// hyphen (-), and period (.). The name must not start or end with a period,
	// and it should not have successive periods. The name is case sensitive and
	// must be unique among all attribute names for the message. The name can be
	// up to 256 characters long. The name cannot start with "AWS." or "Amazon."
	// (or any variations in casing), because these prefixes are reserved for use
	// by Amazon Web Services.
	//
	// When using ReceiveMessage, you can send a list of attribute names to receive,
	// or you can return all of the attributes by specifying "All" or ".*" in your
	// request. You can also use "foo.*" to return all message attributes starting
	// with the "foo" prefix.
	MessageAttributeNames []*string `locationNameList:"MessageAttributeName" type:"list" flattened:"true"`

	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	// The duration (in seconds) that the received messages are hidden from subsequent
	// retrieve requests after being retrieved by a ReceiveMessage request.
	VisibilityTimeout *int64 `type:"integer"`

	// The duration (in seconds) for which the call will wait for a message to arrive
	// in the queue before returning. If a message is available, the call will return
	// sooner than WaitTimeSeconds.
	WaitTimeSeconds *int64 `type:"integer"`

	metadataReceiveMessageInput `json:"-" xml:"-"`
}

type metadataReceiveMessageInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// A list of received messages.
type ReceiveMessageOutput struct {
	// A list of messages.
	Messages []*Message `locationNameList:"Message" type:"list" flattened:"true"`

	metadataReceiveMessageOutput `json:"-" xml:"-"`
}

type metadataReceiveMessageOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type RemovePermissionInput struct {
	// The identification of the permission to remove. This is the label added with
	// the AddPermission action.
	Label *string `type:"string" required:"true"`

	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataRemovePermissionInput `json:"-" xml:"-"`
}

type metadataRemovePermissionInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type RemovePermissionOutput struct {
	metadataRemovePermissionOutput `json:"-" xml:"-"`
}

type metadataRemovePermissionOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type SendMessageBatchInput struct {
	// A list of SendMessageBatchRequestEntry items.
	Entries []*SendMessageBatchRequestEntry `locationNameList:"SendMessageBatchRequestEntry" type:"list" flattened:"true" required:"true"`

	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataSendMessageBatchInput `json:"-" xml:"-"`
}

type metadataSendMessageBatchInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// For each message in the batch, the response contains a SendMessageBatchResultEntry
// tag if the message succeeds or a BatchResultErrorEntry tag if the message
// fails.
type SendMessageBatchOutput struct {
	// A list of BatchResultErrorEntry items with the error detail about each message
	// that could not be enqueued.
	Failed []*BatchResultErrorEntry `locationNameList:"BatchResultErrorEntry" type:"list" flattened:"true" required:"true"`

	// A list of SendMessageBatchResultEntry items.
	Successful []*SendMessageBatchResultEntry `locationNameList:"SendMessageBatchResultEntry" type:"list" flattened:"true" required:"true"`

	metadataSendMessageBatchOutput `json:"-" xml:"-"`
}

type metadataSendMessageBatchOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Contains the details of a single Amazon SQS message along with a Id.
type SendMessageBatchRequestEntry struct {
	// The number of seconds for which the message has to be delayed.
	DelaySeconds *int64 `type:"integer"`

	// An identifier for the message in this batch. This is used to communicate
	// the result. Note that the Ids of a batch request need to be unique within
	// the request.
	ID *string `locationName:"Id" type:"string" required:"true"`

	// Each message attribute consists of a Name, Type, and Value. For more information,
	// see Message Attribute Items (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSMessageAttributes.html#SQSMessageAttributesNTV).
	MessageAttributes map[string]*MessageAttributeValue `locationName:"MessageAttribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`

	// Body of the message.
	MessageBody *string `type:"string" required:"true"`

	metadataSendMessageBatchRequestEntry `json:"-" xml:"-"`
}

type metadataSendMessageBatchRequestEntry struct {
	SDKShapeTraits bool `type:"structure"`
}

// Encloses a message ID for successfully enqueued message of a SendMessageBatch.
type SendMessageBatchResultEntry struct {
	// An identifier for the message in this batch.
	ID *string `locationName:"Id" type:"string" required:"true"`

	// An MD5 digest of the non-URL-encoded message attribute string. This can be
	// used to verify that Amazon SQS received the message batch correctly. Amazon
	// SQS first URL decodes the message before creating the MD5 digest. For information
	// about MD5, go to http://www.faqs.org/rfcs/rfc1321.html (http://www.faqs.org/rfcs/rfc1321.html).
	MD5OfMessageAttributes *string `type:"string"`

	// An MD5 digest of the non-URL-encoded message body string. This can be used
	// to verify that Amazon SQS received the message correctly. Amazon SQS first
	// URL decodes the message before creating the MD5 digest. For information about
	// MD5, go to http://www.faqs.org/rfcs/rfc1321.html (http://www.faqs.org/rfcs/rfc1321.html).
	MD5OfMessageBody *string `type:"string" required:"true"`

	// An identifier for the message.
	MessageID *string `locationName:"MessageId" type:"string" required:"true"`

	metadataSendMessageBatchResultEntry `json:"-" xml:"-"`
}

type metadataSendMessageBatchResultEntry struct {
	SDKShapeTraits bool `type:"structure"`
}

type SendMessageInput struct {
	// The number of seconds (0 to 900 - 15 minutes) to delay a specific message.
	// Messages with a positive DelaySeconds value become available for processing
	// after the delay time is finished. If you don't specify a value, the default
	// value for the queue applies.
	DelaySeconds *int64 `type:"integer"`

	// Each message attribute consists of a Name, Type, and Value. For more information,
	// see Message Attribute Items (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/SQSMessageAttributes.html#SQSMessageAttributesNTV).
	MessageAttributes map[string]*MessageAttributeValue `locationName:"MessageAttribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true"`

	// The message to send. String maximum 256 KB in size. For a list of allowed
	// characters, see the preceding important note.
	MessageBody *string `type:"string" required:"true"`

	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataSendMessageInput `json:"-" xml:"-"`
}

type metadataSendMessageInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// The MD5OfMessageBody and MessageId elements.
type SendMessageOutput struct {
	// An MD5 digest of the non-URL-encoded message attribute string. This can be
	// used to verify that Amazon SQS received the message correctly. Amazon SQS
	// first URL decodes the message before creating the MD5 digest. For information
	// about MD5, go to http://www.faqs.org/rfcs/rfc1321.html (http://www.faqs.org/rfcs/rfc1321.html).
	MD5OfMessageAttributes *string `type:"string"`

	// An MD5 digest of the non-URL-encoded message body string. This can be used
	// to verify that Amazon SQS received the message correctly. Amazon SQS first
	// URL decodes the message before creating the MD5 digest. For information about
	// MD5, go to http://www.faqs.org/rfcs/rfc1321.html (http://www.faqs.org/rfcs/rfc1321.html).
	MD5OfMessageBody *string `type:"string"`

	// An element containing the message ID of the message sent to the queue. For
	// more information, see Queue and Message Identifiers (http://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/ImportantIdentifiers.html)
	// in the Amazon SQS Developer Guide.
	MessageID *string `locationName:"MessageId" type:"string"`

	metadataSendMessageOutput `json:"-" xml:"-"`
}

type metadataSendMessageOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type SetQueueAttributesInput struct {
	// A map of attributes to set.
	//
	// The following lists the names, descriptions, and values of the special request
	// parameters the SetQueueAttributes action uses:
	//
	//    DelaySeconds - The time in seconds that the delivery of all messages
	// in the queue will be delayed. An integer from 0 to 900 (15 minutes). The
	// default for this attribute is 0 (zero).  MaximumMessageSize - The limit of
	// how many bytes a message can contain before Amazon SQS rejects it. An integer
	// from 1024 bytes (1 KiB) up to 262144 bytes (256 KiB). The default for this
	// attribute is 262144 (256 KiB).  MessageRetentionPeriod - The number of seconds
	// Amazon SQS retains a message. Integer representing seconds, from 60 (1 minute)
	// to 1209600 (14 days). The default for this attribute is 345600 (4 days).
	//  Policy - The queue's policy. A valid AWS policy. For more information about
	// policy structure, see Overview of AWS IAM Policies (http://docs.aws.amazon.com/IAM/latest/UserGuide/PoliciesOverview.html)
	// in the Amazon IAM User Guide.  ReceiveMessageWaitTimeSeconds - The time for
	// which a ReceiveMessage call will wait for a message to arrive. An integer
	// from 0 to 20 (seconds). The default for this attribute is 0.   VisibilityTimeout
	// - The visibility timeout for the queue. An integer from 0 to 43200 (12 hours).
	// The default for this attribute is 30. For more information about visibility
	// timeout, see Visibility Timeout in the Amazon SQS Developer Guide.  RedrivePolicy
	// - 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.
	Attributes map[string]*string `locationName:"Attribute" locationNameKey:"Name" locationNameValue:"Value" type:"map" flattened:"true" required:"true"`

	// The URL of the Amazon SQS queue to take action on.
	QueueURL *string `locationName:"QueueUrl" type:"string" required:"true"`

	metadataSetQueueAttributesInput `json:"-" xml:"-"`
}

type metadataSetQueueAttributesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type SetQueueAttributesOutput struct {
	metadataSetQueueAttributesOutput `json:"-" xml:"-"`
}

type metadataSetQueueAttributesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}