sqs

type AddPermissionInput struct {
	// The unique identification of the permission you're setting (for example,
	// AliceSendMessage). Maximum 80 characters. Allowed characters include
	// alphanumeric characters, hyphens (-), and underscores (_).
	Label *string
	// The AWS account number of the principal
	// (https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#P) who is 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
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-making-api-requests.html#sqs-api-request-authentication)
	// in the Amazon Simple Queue Service Developer Guide.
	AWSAccountIds []*string
	// The URL of the Amazon SQS queue to which permissions are added. Queue URLs and
	// names are case-sensitive.
	QueueUrl *string
	// The action the client wants to allow for the specified principal. Valid values:
	// the name of any action or *. For more information about these actions, see
	// Overview of Managing Access Permissions to Your Amazon Simple Queue Service
	// Resource
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-overview-of-managing-access.html)
	// in the Amazon Simple Queue Service Developer Guide. Specifying SendMessage,
	// DeleteMessage, or ChangeMessageVisibility for ActionName.n also grants
	// permissions for the corresponding batch versions of those actions:
	// SendMessageBatch, DeleteMessageBatch, and ChangeMessageVisibilityBatch.
	Actions []*string
}

type AddPermissionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ChangeMessageVisibilityBatchInput struct {
	// A list of receipt handles of the messages for which the visibility timeout must
	// be changed.
	Entries []*types.ChangeMessageVisibilityBatchRequestEntry
	// The URL of the Amazon SQS queue whose messages' visibility is changed. Queue
	// URLs and names are case-sensitive.
	QueueUrl *string
}

type ChangeMessageVisibilityBatchOutput struct {
	// A list of ChangeMessageVisibilityBatchResultEntry () items.
	Successful []*types.ChangeMessageVisibilityBatchResultEntry
	// A list of BatchResultErrorEntry () items.
	Failed []*types.BatchResultErrorEntry

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ChangeMessageVisibilityInput struct {
	// The receipt handle associated with the message whose visibility timeout is
	// changed. This parameter is returned by the ReceiveMessage () action.
	ReceiptHandle *string
	// The new value for the message's visibility timeout (in seconds). Values values:
	// 0 to 43200. Maximum: 12 hours.
	VisibilityTimeout *int32
	// The URL of the Amazon SQS queue whose message's visibility is changed. Queue
	// URLs and names are case-sensitive.
	QueueUrl *string
}

type ChangeMessageVisibilityOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Client struct {
	// contains filtered or unexported fields
}

type CreateQueueInput struct {
	// Add cost allocation tags to the specified Amazon SQS queue. For an overview, see
	// Tagging Your Amazon SQS Queues
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-tags.html)
	// in the Amazon Simple Queue Service Developer Guide.  <p>When you use queue tags,
	// keep the following guidelines in mind:</p> <ul> <li> <p>Adding more than 50 tags
	// to a queue isn't recommended.</p> </li> <li> <p>Tags don't have any semantic
	// meaning. Amazon SQS interprets tags as character strings.</p> </li> <li> <p>Tags
	// are case-sensitive.</p> </li> <li> <p>A new tag with a key identical to that of
	// an existing tag overwrites the existing tag.</p> </li> </ul> <p>For a full list
	// of tag restrictions, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-limits.html#limits-queues">Limits
	// Related to Queues</a> in the <i>Amazon Simple Queue Service Developer
	// Guide</i>.</p> <note> <p>To be able to tag a queue on creation, you must have
	// the <code>sqs:CreateQueue</code> and <code>sqs:TagQueue</code> permissions.</p>
	// <p>Cross-account permissions don't apply to this action. For more information,
	// see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-customer-managed-policy-examples.html#grant-cross-account-permissions-to-role-and-user-name">Grant
	// Cross-Account Permissions to a Role and a User Name</a> in the <i>Amazon Simple
	// Queue Service Developer Guide</i>.</p> </note>
	Tags map[string]*string
	// The name of the new queue. The following limits apply to this name:
	//
	//     * A
	// queue name can have up to 80 characters.
	//
	//     * Valid values: alphanumeric
	// characters, hyphens (-), and underscores (_).
	//
	//     * A FIFO queue name must end
	// with the .fifo suffix.
	//
	// Queue URLs and names are case-sensitive.
	QueueName *string
	// A map of attributes with their corresponding values. The following lists the
	// names, descriptions, and values of the special request parameters that the
	// CreateQueue action uses:
	//
	//     * DelaySeconds – The length of time, in seconds,
	// for which the delivery of all messages in the queue is delayed. Valid values: An
	// integer from 0 to 900 seconds (15 minutes). Default: 0.
	//
	//     *
	// MaximumMessageSize – The limit of how many bytes a message can contain before
	// Amazon SQS rejects it. Valid values: An integer from 1,024 bytes (1 KiB) to
	// 262,144 bytes (256 KiB). Default: 262,144 (256 KiB).
	//
	//     *
	// MessageRetentionPeriod – The length of time, in seconds, for which Amazon SQS
	// retains a message. Valid values: An integer from 60 seconds (1 minute) to
	// 1,209,600 seconds (14 days). Default: 345,600 (4 days).
	//
	//     * Policy – The
	// queue's policy. A valid AWS policy. For more information about policy structure,
	// see Overview of AWS IAM Policies
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/PoliciesOverview.html) in the
	// Amazon IAM User Guide.
	//
	//     * ReceiveMessageWaitTimeSeconds – The length of
	// time, in seconds, for which a ReceiveMessage () action waits for a message to
	// arrive. Valid values: An integer from 0 to 20 (seconds). Default: 0.
	//
	//     *
	// RedrivePolicy – The string that includes the parameters for the dead-letter
	// queue functionality of the source queue as a JSON object. For more information
	// about the redrive policy and dead-letter queues, see Using Amazon SQS
	// Dead-Letter Queues
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html)
	// in the Amazon Simple Queue Service Developer Guide.
	//
	//         *
	// deadLetterTargetArn – The Amazon Resource Name (ARN) of the dead-letter queue to
	// which Amazon SQS moves messages after the value of maxReceiveCount is
	// exceeded.
	//
	//         * maxReceiveCount – The number of times a message is
	// delivered to the source queue before being moved to the dead-letter queue. When
	// the ReceiveCount for a message exceeds the maxReceiveCount for a queue, Amazon
	// SQS moves the message to the dead-letter-queue.
	//
	//     The dead-letter queue of a
	// FIFO queue must also be a FIFO queue. Similarly, the dead-letter queue of a
	// standard queue must also be a standard queue.
	//
	//     * VisibilityTimeout – The
	// visibility timeout for the queue, in seconds. Valid values: An integer from 0 to
	// 43,200 (12 hours). Default: 30. For more information about the visibility
	// timeout, see Visibility Timeout
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
	// in the Amazon Simple Queue Service Developer Guide.
	//
	//     <p>The following
	// attributes apply only to <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html">server-side-encryption</a>:</p>
	// <ul> <li> <p> <code>KmsMasterKeyId</code> – The ID of an AWS-managed customer
	// master key (CMK) for Amazon SQS or a custom CMK. For more information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-sse-key-terms">Key
	// Terms</a>. While the alias of the AWS-managed CMK for Amazon SQS is always
	// <code>alias/aws/sqs</code>, the alias of a custom CMK can, for example, be
	// <code>alias/<i>MyAlias</i> </code>. For more examples, see <a
	// href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">KeyId</a>
	// in the <i>AWS Key Management Service API Reference</i>. </p> </li> <li> <p>
	// <code>KmsDataKeyReusePeriodSeconds</code> – The length of time, in seconds, for
	// which Amazon SQS can reuse a <a
	// href="https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys">data
	// key</a> to encrypt or decrypt messages before calling AWS KMS again. An integer
	// representing seconds, between 60 seconds (1 minute) and 86,400 seconds (24
	// hours). Default: 300 (5 minutes). A shorter time period provides better security
	// but results in more calls to KMS which might incur charges after Free Tier. For
	// more information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-how-does-the-data-key-reuse-period-work">How
	// Does the Data Key Reuse Period Work?</a>. </p> </li> </ul> <p>The following
	// attributes apply only to <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO
	// (first-in-first-out) queues</a>:</p> <ul> <li> <p> <code>FifoQueue</code> –
	// Designates a queue as FIFO. Valid values: <code>true</code>, <code>false</code>.
	// If you don't specify the <code>FifoQueue</code> attribute, Amazon SQS creates a
	// standard queue. You can provide this attribute only during queue creation. You
	// can't change it for an existing queue. When you set this attribute, you must
	// also provide the <code>MessageGroupId</code> for your messages explicitly.</p>
	// <p>For more information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-understanding-logic">FIFO
	// Queue Logic</a> in the <i>Amazon Simple Queue Service Developer Guide</i>.</p>
	// </li> <li> <p> <code>ContentBasedDeduplication</code> – Enables content-based
	// deduplication. Valid values: <code>true</code>, <code>false</code>. For more
	// information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-exactly-once-processing">Exactly-Once
	// Processing</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. </p>
	// <ul> <li> <p>Every message must have a unique
	// <code>MessageDeduplicationId</code>,</p> <ul> <li> <p>You may provide a
	// <code>MessageDeduplicationId</code> explicitly.</p> </li> <li> <p>If you aren't
	// able to provide a <code>MessageDeduplicationId</code> and you enable
	// <code>ContentBasedDeduplication</code> for your queue, Amazon SQS uses a SHA-256
	// hash to generate the <code>MessageDeduplicationId</code> using the body of the
	// message (but not the attributes of the message). </p> </li> <li> <p>If you don't
	// provide a <code>MessageDeduplicationId</code> and the queue doesn't have
	// <code>ContentBasedDeduplication</code> set, the action fails with an error.</p>
	// </li> <li> <p>If the queue has <code>ContentBasedDeduplication</code> set, your
	// <code>MessageDeduplicationId</code> overrides the generated one.</p> </li> </ul>
	// </li> <li> <p>When <code>ContentBasedDeduplication</code> is in effect, messages
	// with identical content sent within the deduplication interval are treated as
	// duplicates and only one copy of the message is delivered.</p> </li> <li> <p>If
	// you send one message with <code>ContentBasedDeduplication</code> enabled and
	// then another message with a <code>MessageDeduplicationId</code> that is the same
	// as the one generated for the first <code>MessageDeduplicationId</code>, the two
	// messages are treated as duplicates and only one copy of the message is
	// delivered. </p> </li> </ul> </li> </ul>
	Attributes map[string]*string
}

type CreateQueueOutput struct {
	// The URL of the created Amazon SQS queue.
	QueueUrl *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteMessageBatchInput struct {
	// A list of receipt handles for the messages to be deleted.
	Entries []*types.DeleteMessageBatchRequestEntry
	// The URL of the Amazon SQS queue from which messages are deleted. Queue URLs and
	// names are case-sensitive.
	QueueUrl *string
}

type DeleteMessageBatchOutput struct {
	// A list of BatchResultErrorEntry () items.
	Failed []*types.BatchResultErrorEntry
	// A list of DeleteMessageBatchResultEntry () items.
	Successful []*types.DeleteMessageBatchResultEntry

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteMessageInput struct {
	// The receipt handle associated with the message to delete.
	ReceiptHandle *string
	// The URL of the Amazon SQS queue from which messages are deleted. Queue URLs and
	// names are case-sensitive.
	QueueUrl *string
}

type DeleteMessageOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteQueueInput struct {
	// The URL of the Amazon SQS queue to delete. Queue URLs and names are
	// case-sensitive.
	QueueUrl *string
}

type DeleteQueueOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options ResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options ResolverOptions) (aws.Endpoint, error)

type GetQueueAttributesInput struct {
	// The URL of the Amazon SQS queue whose attribute information is retrieved. Queue
	// URLs and names are case-sensitive.
	QueueUrl *string
	// A list of attributes for which to retrieve information. In the future, new
	// attributes might be added. If you write code that calls this action, we
	// recommend that you structure your code so that it can handle new attributes
	// gracefully. The following attributes are supported: The
	// ApproximateNumberOfMessagesDelayed, ApproximateNumberOfMessagesNotVisible, and
	// ApproximateNumberOfMessagesVisible metrics may not achieve consistency until at
	// least 1 minute after the producers stop sending messages. This period is
	// required for the queue metadata to reach eventual consistency.
	//
	//     * All –
	// Returns all values.
	//
	//     * ApproximateNumberOfMessages – Returns the approximate
	// number of messages available for retrieval from the queue.
	//
	//     *
	// ApproximateNumberOfMessagesDelayed – Returns the approximate number of messages
	// in the queue that are delayed and not available for reading immediately. This
	// can happen when the queue is configured as a delay queue or when a message has
	// been sent with a delay parameter.
	//
	//     * ApproximateNumberOfMessagesNotVisible –
	// Returns the approximate number of messages that are in flight. Messages are
	// considered to be in flight if they have been sent to a client but have not yet
	// been deleted or have not yet reached the end of their visibility window.
	//
	//     *
	// CreatedTimestamp – Returns the time when the queue was created in seconds (epoch
	// time (http://en.wikipedia.org/wiki/Unix_time)).
	//
	//     * DelaySeconds – Returns
	// the default delay on the queue in seconds.
	//
	//     * LastModifiedTimestamp –
	// Returns the time when the queue was last changed in seconds (epoch time
	// (http://en.wikipedia.org/wiki/Unix_time)).
	//
	//     * MaximumMessageSize – Returns
	// the limit of how many bytes a message can contain before Amazon SQS rejects
	// it.
	//
	//     * MessageRetentionPeriod – Returns the length of time, in seconds, for
	// which Amazon SQS retains a message.
	//
	//     * Policy – Returns the policy of the
	// queue.
	//
	//     * QueueArn – Returns the Amazon resource name (ARN) of the queue.
	//
	//
	// * ReceiveMessageWaitTimeSeconds – Returns the length of time, in seconds, for
	// which the ReceiveMessage action waits for a message to arrive.
	//
	//     *
	// RedrivePolicy – The string that includes the parameters for the dead-letter
	// queue functionality of the source queue as a JSON object. For more information
	// about the redrive policy and dead-letter queues, see Using Amazon SQS
	// Dead-Letter Queues
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html)
	// in the Amazon Simple Queue Service Developer Guide.
	//
	//         *
	// deadLetterTargetArn – The Amazon Resource Name (ARN) of the dead-letter queue to
	// which Amazon SQS moves messages after the value of maxReceiveCount is
	// exceeded.
	//
	//         * maxReceiveCount – The number of times a message is
	// delivered to the source queue before being moved to the dead-letter queue. When
	// the ReceiveCount for a message exceeds the maxReceiveCount for a queue, Amazon
	// SQS moves the message to the dead-letter-queue.
	//
	//     * VisibilityTimeout –
	// Returns the visibility timeout for the queue. For more information about the
	// visibility timeout, see Visibility Timeout
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
	// in the Amazon Simple Queue Service Developer Guide.
	//
	//     <p>The following
	// attributes apply only to <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html">server-side-encryption</a>:</p>
	// <ul> <li> <p> <code>KmsMasterKeyId</code> – Returns the ID of an AWS-managed
	// customer master key (CMK) for Amazon SQS or a custom CMK. For more information,
	// see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-sse-key-terms">Key
	// Terms</a>. </p> </li> <li> <p> <code>KmsDataKeyReusePeriodSeconds</code> –
	// Returns the length of time, in seconds, for which Amazon SQS can reuse a data
	// key to encrypt or decrypt messages before calling AWS KMS again. For more
	// information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-how-does-the-data-key-reuse-period-work">How
	// Does the Data Key Reuse Period Work?</a>. </p> </li> </ul> <p>The following
	// attributes apply only to <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO
	// (first-in-first-out) queues</a>:</p> <ul> <li> <p> <code>FifoQueue</code> –
	// Returns whether the queue is FIFO. For more information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-understanding-logic">FIFO
	// Queue Logic</a> in the <i>Amazon Simple Queue Service Developer Guide</i>.</p>
	// <note> <p>To determine whether a queue is <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO</a>,
	// you can check whether <code>QueueName</code> ends with the <code>.fifo</code>
	// suffix.</p> </note> </li> <li> <p> <code>ContentBasedDeduplication</code> –
	// Returns whether content-based deduplication is enabled for the queue. For more
	// information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-exactly-once-processing">Exactly-Once
	// Processing</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. </p>
	// </li> </ul>
	AttributeNames []types.QueueAttributeName
}

type GetQueueAttributesOutput struct {
	// A map of attributes to their respective values.
	Attributes map[string]*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetQueueUrlInput struct {
	// The AWS account ID of the account that created the queue.
	QueueOwnerAWSAccountId *string
	// The name of the queue whose URL must be fetched. Maximum 80 characters. Valid
	// values: alphanumeric characters, hyphens (-), and underscores (_). Queue URLs
	// and names are case-sensitive.
	QueueName *string
}

type GetQueueUrlOutput struct {
	// The URL of the queue.
	QueueUrl *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type ListDeadLetterSourceQueuesInput struct {
	// The URL of a dead-letter queue. Queue URLs and names are case-sensitive.
	QueueUrl *string
	// Maximum number of results to include in the response.
	MaxResults *int32
	// Pagination token to request the next set of results.
	NextToken *string
}

type ListDeadLetterSourceQueuesOutput struct {
	// Pagination token to include in the next request.
	NextToken *string
	// A list of source queue URLs that have the RedrivePolicy queue attribute
	// configured with a dead-letter queue.
	QueueUrls []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListQueueTagsInput struct {
	// The URL of the queue.
	QueueUrl *string
}

type ListQueueTagsOutput struct {
	// The list of all tags added to the specified queue.
	Tags map[string]*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListQueuesInput struct {
	// Pagination token to request the next set of results.
	NextToken *string
	// Maximum number of results to include in the response.
	MaxResults *int32
	// A string to use for filtering the list results. Only those queues whose name
	// begins with the specified string are returned. Queue URLs and names are
	// case-sensitive.
	QueueNamePrefix *string
}

type ListQueuesOutput struct {
	// Pagination token to include in the next request.
	NextToken *string
	// A list of queue URLs, up to 1,000 entries, or the value of MaxResults that you
	// sent in the request.
	QueueUrls []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions ResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type PurgeQueueInput struct {
	// The URL of the queue from which the PurgeQueue action deletes messages. Queue
	// URLs and names are case-sensitive.
	QueueUrl *string
}

type PurgeQueueOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ReceiveMessageInput struct {
	// The name of the message attribute, where N is the index.
	//
	//     * The name can
	// contain alphanumeric characters and the underscore (_), hyphen (-), and period
	// (.).
	//
	//     * The name is case-sensitive and must be unique among all attribute
	// names for the message.
	//
	//     * The name must not start with AWS-reserved prefixes
	// such as AWS. or Amazon. (or any casing variants).
	//
	//     * The name must not start
	// or end with a period (.), and it should not have periods in succession (..).
	//
	//
	// * The name can be up to 256 characters long.
	//
	//     <p>When using
	// <code>ReceiveMessage</code>, you can send a list of attribute names to receive,
	// or you can return all of the attributes by specifying <code>All</code> or
	// <code>.*</code> in your request. You can also use all message attributes
	// starting with a prefix, for example <code>bar.*</code>.</p>
	MessageAttributeNames []*string
	// The duration (in seconds) for which the call waits for a message to arrive in
	// the queue before returning. If a message is available, the call returns sooner
	// than WaitTimeSeconds. If no messages are available and the wait time expires,
	// the call returns successfully with an empty list of messages. To avoid HTTP
	// errors, ensure that the HTTP response timeout for ReceiveMessage requests is
	// longer than the WaitTimeSeconds parameter. For example, with the Java SDK, you
	// can set HTTP transport settings using the  NettyNioAsyncHttpClient
	// (https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/nio/netty/NettyNioAsyncHttpClient.html)
	// for asynchronous clients, or the  ApacheHttpClient
	// (https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/http/apache/ApacheHttpClient.html)
	// for synchronous clients.
	WaitTimeSeconds *int32
	// The URL of the Amazon SQS queue from which messages are received. Queue URLs and
	// names are case-sensitive.
	QueueUrl *string
	// A list of attributes that need to be returned along with each message. These
	// attributes include:
	//
	//     * All – Returns all values.
	//
	//     *
	// ApproximateFirstReceiveTimestamp – Returns the time the message was first
	// received from the queue (epoch time (http://en.wikipedia.org/wiki/Unix_time) in
	// milliseconds).
	//
	//     * ApproximateReceiveCount – Returns the number of times a
	// message has been received across all queues but not deleted.
	//
	//     *
	// AWSTraceHeader – Returns the AWS X-Ray trace header string.
	//
	//     * SenderId
	//
	//
	// * For an IAM user, returns the IAM user ID, for example ABCDEFGHI1JKLMNOPQ23R.
	//
	//
	// * For an IAM role, returns the IAM role ID, for example
	// ABCDE1F2GH3I4JK5LMNOP:i-a123b456.
	//
	//     * SentTimestamp – Returns the time the
	// message was sent to the queue (epoch time
	// (http://en.wikipedia.org/wiki/Unix_time) in milliseconds).
	//
	//     *
	// MessageDeduplicationId – Returns the value provided by the producer that calls
	// the SendMessage () action.
	//
	//     * MessageGroupId – Returns the value provided by
	// the producer that calls the SendMessage () action. Messages with the same
	// MessageGroupId are returned in sequence.
	//
	//     * SequenceNumber – Returns the
	// value provided by Amazon SQS.
	AttributeNames []types.QueueAttributeName
	// The maximum number of messages to return. Amazon SQS never returns more messages
	// than this value (however, fewer messages might be returned). Valid values: 1 to
	// 10. Default: 1.
	MaxNumberOfMessages *int32
	// The duration (in seconds) that the received messages are hidden from subsequent
	// retrieve requests after being retrieved by a ReceiveMessage request.
	VisibilityTimeout *int32
	// This parameter applies only to FIFO (first-in-first-out) queues. The token used
	// for deduplication of ReceiveMessage calls. If a networking issue occurs after a
	// ReceiveMessage action, and instead of a response you receive a generic error, it
	// is possible to retry the same action with an identical ReceiveRequestAttemptId
	// to retrieve the same set of messages, even if their visibility timeout has not
	// yet expired.
	//
	//     * You can use ReceiveRequestAttemptId only for 5 minutes after
	// a ReceiveMessage action.
	//
	//     * When you set FifoQueue, a caller of the
	// ReceiveMessage action can provide a ReceiveRequestAttemptId explicitly.
	//
	//     *
	// If a caller of the ReceiveMessage action doesn't provide a
	// ReceiveRequestAttemptId, Amazon SQS generates a ReceiveRequestAttemptId.
	//
	//     *
	// It is possible to retry the ReceiveMessage action with the same
	// ReceiveRequestAttemptId if none of the messages have been modified (deleted or
	// had their visibility changes).
	//
	//     * During a visibility timeout, subsequent
	// calls with the same ReceiveRequestAttemptId return the same messages and receipt
	// handles. If a retry occurs within the deduplication interval, it resets the
	// visibility timeout. For more information, see Visibility Timeout
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
	// in the Amazon Simple Queue Service Developer Guide. If a caller of the
	// ReceiveMessage action still processes messages when the visibility timeout
	// expires and messages become visible, another worker consuming from the same
	// queue can receive the same messages and therefore process duplicates. Also, if a
	// consumer whose message processing time is longer than the visibility timeout
	// tries to delete the processed messages, the action fails with an error. To
	// mitigate this effect, ensure that your application observes a safe threshold
	// before the visibility timeout expires and extend the visibility timeout as
	// necessary.
	//
	//     * While messages with a particular MessageGroupId are invisible,
	// no more messages belonging to the same MessageGroupId are returned until the
	// visibility timeout expires. You can still receive messages with another
	// MessageGroupId as long as it is also visible.
	//
	//     * If a caller of
	// ReceiveMessage can't track the ReceiveRequestAttemptId, no retries work until
	// the original visibility timeout expires. As a result, delays might occur but the
	// messages in the queue remain in a strict order.
	//
	// The maximum length of
	// ReceiveRequestAttemptId is 128 characters. ReceiveRequestAttemptId can contain
	// alphanumeric characters (a-z, A-Z, 0-9) and punctuation
	// (!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~). For best practices of using
	// ReceiveRequestAttemptId, see Using the ReceiveRequestAttemptId Request Parameter
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-receiverequestattemptid-request-parameter.html)
	// in the Amazon Simple Queue Service Developer Guide.
	ReceiveRequestAttemptId *string
}

type ReceiveMessageOutput struct {
	// A list of messages.
	Messages []*types.Message

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RemovePermissionInput struct {
	// The URL of the Amazon SQS queue from which permissions are removed. Queue URLs
	// and names are case-sensitive.
	QueueUrl *string
	// The identification of the permission to remove. This is the label added using
	// the AddPermission () action.
	Label *string
}

type RemovePermissionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type SendMessageBatchInput struct {
	// A list of SendMessageBatchRequestEntry () items.
	Entries []*types.SendMessageBatchRequestEntry
	// The URL of the Amazon SQS queue to which batched messages are sent. Queue URLs
	// and names are case-sensitive.
	QueueUrl *string
}

type SendMessageBatchOutput struct {
	// A list of SendMessageBatchResultEntry () items.
	Successful []*types.SendMessageBatchResultEntry
	// A list of BatchResultErrorEntry () items with error details about each message
	// that can't be enqueued.
	Failed []*types.BatchResultErrorEntry

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SendMessageInput struct {
	// Each message attribute consists of a Name, Type, and Value. For more
	// information, see Amazon SQS Message Attributes
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-attributes.html)
	// in the Amazon Simple Queue Service Developer Guide.
	MessageAttributes map[string]*types.MessageAttributeValue
	// This parameter applies only to FIFO (first-in-first-out) queues. The tag that
	// specifies that a message belongs to a specific message group. Messages that
	// belong to the same message group are processed in a FIFO manner (however,
	// messages in different message groups might be processed out of order). To
	// interleave multiple ordered streams within a single queue, use MessageGroupId
	// values (for example, session data for multiple users). In this scenario,
	// multiple consumers can process the queue, but the session data of each user is
	// processed in a FIFO fashion.
	//
	//     * You must associate a non-empty
	// MessageGroupId with a message. If you don't provide a MessageGroupId, the action
	// fails.
	//
	//     * ReceiveMessage might return messages with multiple MessageGroupId
	// values. For each MessageGroupId, the messages are sorted by time sent. The
	// caller can't specify a MessageGroupId.
	//
	// The length of MessageGroupId is 128
	// characters. Valid values: alphanumeric characters and punctuation
	// (!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~). For best practices of using MessageGroupId,
	// see Using the MessageGroupId Property
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-messagegroupid-property.html)
	// in the Amazon Simple Queue Service Developer Guide. MessageGroupId is required
	// for FIFO queues. You can't use it for Standard queues.
	MessageGroupId *string
	// This parameter applies only to FIFO (first-in-first-out) queues. The token used
	// for deduplication of sent messages. If a message with a particular
	// MessageDeduplicationId is sent successfully, any messages sent with the same
	// MessageDeduplicationId are accepted successfully but aren't delivered during the
	// 5-minute deduplication interval. For more information, see  Exactly-Once
	// Processing
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-exactly-once-processing)
	// in the Amazon Simple Queue Service Developer Guide.
	//
	//     * Every message must
	// have a unique MessageDeduplicationId,
	//
	//         * You may provide a
	// MessageDeduplicationId explicitly.
	//
	//         * If you aren't able to provide a
	// MessageDeduplicationId and you enable ContentBasedDeduplication for your queue,
	// Amazon SQS uses a SHA-256 hash to generate the MessageDeduplicationId using the
	// body of the message (but not the attributes of the message).
	//
	//         * If you
	// don't provide a MessageDeduplicationId and the queue doesn't have
	// ContentBasedDeduplication set, the action fails with an error.
	//
	//         * If the
	// queue has ContentBasedDeduplication set, your MessageDeduplicationId overrides
	// the generated one.
	//
	//     * When ContentBasedDeduplication is in effect, messages
	// with identical content sent within the deduplication interval are treated as
	// duplicates and only one copy of the message is delivered.
	//
	//     * If you send one
	// message with ContentBasedDeduplication enabled and then another message with a
	// MessageDeduplicationId that is the same as the one generated for the first
	// MessageDeduplicationId, the two messages are treated as duplicates and only one
	// copy of the message is delivered.
	//
	// The MessageDeduplicationId is available to
	// the consumer of the message (this can be useful for troubleshooting delivery
	// issues). If a message is sent successfully but the acknowledgement is lost and
	// the message is resent with the same MessageDeduplicationId after the
	// deduplication interval, Amazon SQS can't detect duplicate messages. Amazon SQS
	// continues to keep track of the message deduplication ID even after the message
	// is received and deleted. The maximum length of MessageDeduplicationId is 128
	// characters. MessageDeduplicationId can contain alphanumeric characters (a-z,
	// A-Z, 0-9) and punctuation (!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~). For best practices
	// of using MessageDeduplicationId, see Using the MessageDeduplicationId Property
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-messagededuplicationid-property.html)
	// in the Amazon Simple Queue Service Developer Guide.
	MessageDeduplicationId *string
	// The length of time, in seconds, for which to delay a specific message. Valid
	// values: 0 to 900. Maximum: 15 minutes. Messages with a positive DelaySeconds
	// value become available for processing after the delay period is finished. If you
	// don't specify a value, the default value for the queue applies. When you set
	// FifoQueue, you can't set DelaySeconds per message. You can set this parameter
	// only on a queue level.
	DelaySeconds *int32
	// The URL of the Amazon SQS queue to which a message is sent. Queue URLs and names
	// are case-sensitive.
	QueueUrl *string
	// The message system attribute to send. Each message system attribute consists of
	// a Name, Type, and Value.
	//
	//     * Currently, the only supported message system
	// attribute is AWSTraceHeader. Its type must be String and its value must be a
	// correctly formatted AWS X-Ray trace header string.
	//
	//     * The size of a message
	// system attribute doesn't count towards the total size of a message.
	MessageSystemAttributes map[string]*types.MessageSystemAttributeValue
	// The message to send. The maximum string size is 256 KB. A message can include
	// only XML, JSON, and unformatted text. The following Unicode characters are
	// allowed: #x9 | #xA | #xD | #x20 to #xD7FF | #xE000 to #xFFFD | #x10000 to
	// #x10FFFF Any characters not included in this list will be rejected. For more
	// information, see the W3C specification for characters
	// (http://www.w3.org/TR/REC-xml/#charsets).
	MessageBody *string
}

type SendMessageOutput struct {
	// An MD5 digest of the non-URL-encoded message system attribute string. You can
	// use this attribute to verify that Amazon SQS received the message correctly.
	// Amazon SQS URL-decodes the message before creating the MD5 digest.
	MD5OfMessageSystemAttributes *string
	// This parameter applies only to FIFO (first-in-first-out) queues. The large,
	// non-consecutive number that Amazon SQS assigns to each message. The length of
	// SequenceNumber is 128 bits. SequenceNumber continues to increase for a
	// particular MessageGroupId.
	SequenceNumber *string
	// An MD5 digest of the non-URL-encoded message attribute string. You can use this
	// attribute to verify that Amazon SQS received the message correctly. Amazon SQS
	// URL-decodes the message before creating the MD5 digest. For information about
	// MD5, see RFC1321 (https://www.ietf.org/rfc/rfc1321.txt).
	MD5OfMessageAttributes *string
	// An MD5 digest of the non-URL-encoded message attribute string. You can use this
	// attribute to verify that Amazon SQS received the message correctly. Amazon SQS
	// URL-decodes the message before creating the MD5 digest. For information about
	// MD5, see RFC1321 (https://www.ietf.org/rfc/rfc1321.txt).
	MD5OfMessageBody *string
	// An attribute containing the MessageId of the message sent to the queue. For more
	// information, see Queue and Message Identifiers
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-queue-message-identifiers.html)
	// in the Amazon Simple Queue Service Developer Guide.
	MessageId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SetQueueAttributesInput struct {
	// The URL of the Amazon SQS queue whose attributes are set. Queue URLs and names
	// are case-sensitive.
	QueueUrl *string
	// A map of attributes to set. The following lists the names, descriptions, and
	// values of the special request parameters that the SetQueueAttributes action
	// uses:
	//
	//     * DelaySeconds – The length of time, in seconds, for which the
	// delivery of all messages in the queue is delayed. Valid values: An integer from
	// 0 to 900 (15 minutes). Default: 0.
	//
	//     * MaximumMessageSize – The limit of how
	// many bytes a message can contain before Amazon SQS rejects it. Valid values: An
	// integer from 1,024 bytes (1 KiB) up to 262,144 bytes (256 KiB). Default: 262,144
	// (256 KiB).
	//
	//     * MessageRetentionPeriod – The length of time, in seconds, for
	// which Amazon SQS retains a message. Valid values: An integer representing
	// seconds, from 60 (1 minute) to 1,209,600 (14 days). Default: 345,600 (4 days).
	//
	//
	// * Policy – The queue's policy. A valid AWS policy. For more information about
	// policy structure, see Overview of AWS IAM Policies
	// (https://docs.aws.amazon.com/IAM/latest/UserGuide/PoliciesOverview.html) in the
	// Amazon IAM User Guide.
	//
	//     * ReceiveMessageWaitTimeSeconds – The length of
	// time, in seconds, for which a ReceiveMessage () action waits for a message to
	// arrive. Valid values: An integer from 0 to 20 (seconds). Default: 0.
	//
	//     *
	// RedrivePolicy – The string that includes the parameters for the dead-letter
	// queue functionality of the source queue as a JSON object. For more information
	// about the redrive policy and dead-letter queues, see Using Amazon SQS
	// Dead-Letter Queues
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html)
	// in the Amazon Simple Queue Service Developer Guide.
	//
	//         *
	// deadLetterTargetArn – The Amazon Resource Name (ARN) of the dead-letter queue to
	// which Amazon SQS moves messages after the value of maxReceiveCount is
	// exceeded.
	//
	//         * maxReceiveCount – The number of times a message is
	// delivered to the source queue before being moved to the dead-letter queue. When
	// the ReceiveCount for a message exceeds the maxReceiveCount for a queue, Amazon
	// SQS moves the message to the dead-letter-queue.
	//
	//     The dead-letter queue of a
	// FIFO queue must also be a FIFO queue. Similarly, the dead-letter queue of a
	// standard queue must also be a standard queue.
	//
	//     * VisibilityTimeout – The
	// visibility timeout for the queue, in seconds. Valid values: An integer from 0 to
	// 43,200 (12 hours). Default: 30. For more information about the visibility
	// timeout, see Visibility Timeout
	// (https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html)
	// in the Amazon Simple Queue Service Developer Guide.
	//
	//     <p>The following
	// attributes apply only to <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html">server-side-encryption</a>:</p>
	// <ul> <li> <p> <code>KmsMasterKeyId</code> – The ID of an AWS-managed customer
	// master key (CMK) for Amazon SQS or a custom CMK. For more information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-sse-key-terms">Key
	// Terms</a>. While the alias of the AWS-managed CMK for Amazon SQS is always
	// <code>alias/aws/sqs</code>, the alias of a custom CMK can, for example, be
	// <code>alias/<i>MyAlias</i> </code>. For more examples, see <a
	// href="https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters">KeyId</a>
	// in the <i>AWS Key Management Service API Reference</i>. </p> </li> <li> <p>
	// <code>KmsDataKeyReusePeriodSeconds</code> – The length of time, in seconds, for
	// which Amazon SQS can reuse a <a
	// href="https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys">data
	// key</a> to encrypt or decrypt messages before calling AWS KMS again. An integer
	// representing seconds, between 60 seconds (1 minute) and 86,400 seconds (24
	// hours). Default: 300 (5 minutes). A shorter time period provides better security
	// but results in more calls to KMS which might incur charges after Free Tier. For
	// more information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-server-side-encryption.html#sqs-how-does-the-data-key-reuse-period-work">How
	// Does the Data Key Reuse Period Work?</a>. </p> </li> </ul> <p>The following
	// attribute applies only to <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html">FIFO
	// (first-in-first-out) queues</a>:</p> <ul> <li> <p>
	// <code>ContentBasedDeduplication</code> – Enables content-based deduplication.
	// For more information, see <a
	// href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html#FIFO-queues-exactly-once-processing">Exactly-Once
	// Processing</a> in the <i>Amazon Simple Queue Service Developer Guide</i>. </p>
	// <ul> <li> <p>Every message must have a unique
	// <code>MessageDeduplicationId</code>,</p> <ul> <li> <p>You may provide a
	// <code>MessageDeduplicationId</code> explicitly.</p> </li> <li> <p>If you aren't
	// able to provide a <code>MessageDeduplicationId</code> and you enable
	// <code>ContentBasedDeduplication</code> for your queue, Amazon SQS uses a SHA-256
	// hash to generate the <code>MessageDeduplicationId</code> using the body of the
	// message (but not the attributes of the message). </p> </li> <li> <p>If you don't
	// provide a <code>MessageDeduplicationId</code> and the queue doesn't have
	// <code>ContentBasedDeduplication</code> set, the action fails with an error.</p>
	// </li> <li> <p>If the queue has <code>ContentBasedDeduplication</code> set, your
	// <code>MessageDeduplicationId</code> overrides the generated one.</p> </li> </ul>
	// </li> <li> <p>When <code>ContentBasedDeduplication</code> is in effect, messages
	// with identical content sent within the deduplication interval are treated as
	// duplicates and only one copy of the message is delivered.</p> </li> <li> <p>If
	// you send one message with <code>ContentBasedDeduplication</code> enabled and
	// then another message with a <code>MessageDeduplicationId</code> that is the same
	// as the one generated for the first <code>MessageDeduplicationId</code>, the two
	// messages are treated as duplicates and only one copy of the message is
	// delivered. </p> </li> </ul> </li> </ul>
	Attributes map[string]*string
}

type SetQueueAttributesOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TagQueueInput struct {
	// The list of tags to be added to the specified queue.
	Tags map[string]*string
	// The URL of the queue.
	QueueUrl *string
}

type TagQueueOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UntagQueueInput struct {
	// The URL of the queue.
	QueueUrl *string
	// The list of tags to be removed from the specified queue.
	TagKeys []*string
}

type UntagQueueOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}