AsyncAws SQS

https://github.com/async-aws/sqs
Admin
AsyncAws SQS is an asynchronous API client for Amazon SQS (Simple Queue Service) that enables...
Tokens:67,757
Snippets:438
Trust Score:7.4
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install AsyncAws SQS via Composer

Source: https://github.com/async-aws/sqs/blob/master/README.md

Use this command to install the AsyncAws SQS client package. Run it in your terminal within your project directory.

```cli
composer require async-aws/sqs
```

--------------------------------

### SendMessageBatchRequest usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-send-receive.md

Shows how to create a SendMessageBatchRequest with a queue URL and entries, using both object and array forms for entries, then send the batch and get successful results.

```php
use AsyncAws\Sqs\Input\SendMessageBatchRequest;
use AsyncAws\Sqs\ValueObject\SendMessageBatchRequestEntry;

$input = (new SendMessageBatchRequest())
    ->setQueueUrl($url)
    ->setEntries([
        new SendMessageBatchRequestEntry(['Id' => 'm1', 'MessageBody' => 'one']),
        ['Id' => 'm2', 'MessageBody' => 'two', 'DelaySeconds' => 5], // array form is accepted
    ]);
$sqs->sendMessageBatch($input)->getSuccessful();
```

--------------------------------

### Start a message move task and get the task handle

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-move-tasks.md

Calls startMessageMoveTask with source and destination ARNs and an optional rate limit, then retrieves the task handle. The handle is required for cancelMessageMoveTask and listMessageMoveTasks.

```php
$result = $sqs->startMessageMoveTask([
    'SourceArn' => 'arn:aws:sqs:us-east-1:123456789012:orders-dlq',
    'DestinationArn' => 'arn:aws:sqs:us-east-1:123456789012:orders',
    'MaxNumberOfMessagesPerSecond' => 5,
]);
$handle = $result->getTaskHandle();
if (null !== $handle) {
    // pass $handle to cancelMessageMoveTask / listMessageMoveTasks
}
```

--------------------------------

### SqsClient Constructor

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/configuration.md

Documentation for the SqsClient constructor, including parameters and usage example.

```APIDOC
## SqsClient Constructor

### Description
Creates a new SQS client instance. The constructor is inherited from `AsyncAws\Core\AbstractApi` and accepts a configuration array and an optional credentials provider.

### Method
Constructor

### Endpoint
`new SqsClient(array $configuration = [], $credentialProvider = null)`

### Parameters
#### Constructor Parameters
- **$configuration** (array) - Optional - Client-wide settings. The only key exercised in this repository is `'endpoint'`; `'region'` participates through `Configuration::DEFAULT_REGION`.
- **$credentialProvider** (Core credentials provider) - Optional - Credentials used for SigV4 signing; `AsyncAws\Core\Credentials\NullProvider` is used in the integration test.

### Request Example
```php
use AsyncAws\Sqs\SqsClient;
use AsyncAws\Core\Credentials\NullProvider;

$client = new SqsClient([
    'endpoint' => 'http://localhost:9494', // local fake-SQS endpoint
], new NullProvider());
```

### Response
#### Success Response
Returns an `SqsClient` instance.

#### Response Example
```php
$client = new SqsClient([
    'endpoint' => 'http://localhost:9494',
], new NullProvider());
```
```

--------------------------------

### StartMessageMoveTaskRequest

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-misc.md

Documentation for the StartMessageMoveTaskRequest input class used to start a message move task.

```APIDOC
## StartMessageMoveTaskRequest

### Description
Creates a request to start a message move task in Amazon SQS. This input class is used with the `startMessageMoveTask` operation.

### Method
N/A (SDK input class)

### Endpoint
N/A (SDK input class)

### Parameters
#### Constructor / create()
- **SourceArn** (string) - Required - The ARN of the source queue (e.g., a dead-letter queue).
- **DestinationArn** (string|null) - Optional - The ARN of the destination queue.
- **MaxNumberOfMessagesPerSecond** (int|null) - Optional - The maximum number of messages to move per second.

### Request Example
```php
$input = new StartMessageMoveTaskRequest([
    'SourceArn' => 'arn:aws:sqs:us-east-1:123456789012:orders-dlq',
    'DestinationArn' => 'arn:aws:sqs:us-east-1:123456789012:orders',
    'MaxNumberOfMessagesPerSecond' => 10,
]);
$handle = $sqs->startMessageMoveTask($input)->getTaskHandle();
```

### Response
N/A (returns a result object with `getTaskHandle()`).
```

--------------------------------

### List dead-letter source queues example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-misc.md

Example usage of listDeadLetterSourceQueues with a ListDeadLetterSourceQueuesRequest. QueueUrl is required; MaxResults is optional.

```php
$input = (new ListDeadLetterSourceQueuesRequest())
    ->setQueueUrl($dlqUrl)
    ->setMaxResults(500);
foreach ($sqs->listDeadLetterSourceQueues($input) as $sourceUrl) {
    // ...
}
```

--------------------------------

### AddPermissionRequest usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-misc.md

Example of creating an AddPermissionRequest with all required fields and calling addPermission. The example uses a queue URL variable and a sample AWS account ID.

```php
use AsyncAws\Sqs\Input\AddPermissionRequest;

$input = new AddPermissionRequest([
    'QueueUrl' => $queueUrl,
    'Label' => 'bob-read',
    'AWSAccountIds' => ['123456789012'],
    'Actions' => ['ReceiveMessage'],
]);
$sqs->addPermission($input)->resolve();
```

--------------------------------

### startMessageMoveTask($input)

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client.md

Starts a message move task. The input is a StartMessageMoveTaskRequest object or an array of parameters.

```APIDOC
## startMessageMoveTask($input)

### Description
Starts a message move task. The input is a StartMessageMoveTaskRequest object or an array of parameters.

### Method
startMessageMoveTask

### Parameters
- **$input** (StartMessageMoveTaskRequest|array) - Required - The request object or array of parameters for the StartMessageMoveTask operation.

### Return Type
StartMessageMoveTaskResult

### Source
src/SqsClient.php:1043
```

--------------------------------

### CreateQueueRequest

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-queue-lifecycle.md

Documentation for the CreateQueueRequest input class, including constructor, methods, validation, and an example.

```APIDOC
## CreateQueueRequest

### Description
Creates a new standard or FIFO queue. You must pass the name of the queue that you want to create. The queue name must be unique within the AWS account.

### Constructor
`public function __construct(array $input = [])`

Accepts an associative array keyed by PascalCase AWS names. All keys are optional at construction; required keys are enforced in `requestBody()`.

### Static Factory
`public static function create($input): self`

Returns `$input` itself if already an instance, otherwise `new self($input)`.

### Methods
- `public function getQueueName(): ?string`
- `public function getAttributes(): array` — array<QueueAttributeName::*, string>
- `public function getTags(): array` — array<string, string>
- `public function setQueueName(?string $value): self`
- `public function setAttributes(array $value): self`
- `public function setTags(array $value): self`
- `public function request(): Request` — builds the AsyncAws\Core\Request: POST /, headers Content-Type: application/x-amz-json-1.0, X-Amz-Target: AmazonSQS.CreateQueue, Accept: application/json, JSON-encoded body.

### Constructor Keys
- `QueueName?` (string|null) - Optional - The name of the new queue.
- `Attributes?` (array<QueueAttributeName::*, string>|null) - Optional - A map of attributes with their corresponding values.
- `tags?` (array<string, string>|null) - Optional - A map of tags with their corresponding values.

### Validation
- `QueueName` is required. Missing parameter "QueueName" error is thrown if not provided.
- Each `Attributes` key must satisfy `QueueAttributeName::exists($name)` or an `InvalidArgument` with `Invalid key for ... not a valid "QueueAttributeName"` is thrown.
- An empty map is serialized as `{}`.

### Example
```php
use AsyncAws\Sqs\Input\CreateQueueRequest;
use AsyncAws\Sqs\Enum\QueueAttributeName;

$input = (new CreateQueueRequest())
    ->setQueueName('events')
    ->setAttributes([QueueAttributeName::DELAY_SECONDS => '0', QueueAttributeName::VISIBILITY_TIMEOUT => '30'])
    ->setTags(['env' => 'prod']);
$sqs->createQueue($input)->getQueueUrl();
```
```

--------------------------------

### changeMessageVisibilityBatch usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-messaging.md

Example of calling changeMessageVisibilityBatch with an array of entries, then iterating over failed results to log errors. The example sets VisibilityTimeout to 0 for immediate visibility.

```php
$result = $sqs->changeMessageVisibilityBatch([
    'QueueUrl' => $url,
    'Entries' => [['Id' => 'v1', 'ReceiptHandle' => $h1, 'VisibilityTimeout' => 0]],
]);
foreach ($result->getFailed() as $err) {
    error_log($err->getCode(), $err->getMessage());
}
```

--------------------------------

### PurgeQueueRequest usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-misc.md

Example of using PurgeQueueRequest with setQueueUrl and calling purgeQueue. The queue URL is provided via a variable.

```php
$sqs->purgeQueue((new PurgeQueueRequest())->setQueueUrl($queueUrl))->resolve();
```

--------------------------------

### Error handling example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-messaging.md

Shows how to catch MessageNotInflightException when the message is no longer in flight (already deleted or expired). The example sets a visibility timeout of 10 seconds.

```php
use AsyncAws\Sqs\Exception\MessageNotInflightException;

try {
    $sqs->changeMessageVisibility(['QueueUrl' => $url, 'ReceiptHandle' => $h, 'VisibilityTimeout' => 10])->resolve();
} catch (MessageNotInflightException $e) {
    // message is no longer in flight (already deleted or expired)
}
```

--------------------------------

### Create a queue with CreateQueueRequest

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-queue-lifecycle.md

Example of creating a CreateQueueRequest with queue name, attributes, and tags, then sending it to SqsClient::createQueue and retrieving the queue URL. Requires the AsyncAws SQS package.

```php
use AsyncAws\Sqs\Input\CreateQueueRequest;
use AsyncAws\Sqs\Enum\QueueAttributeName;

$input = (new CreateQueueRequest())
    ->setQueueName('events')
    ->setAttributes([QueueAttributeName::DELAY_SECONDS => '0', QueueAttributeName::VISIBILITY_TIMEOUT => '30'])
    ->setTags(['env' => 'prod']);
$sqs->createQueue($input)->getQueueUrl();
```

--------------------------------

### startMessageMoveTask

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-message-move-tasks.md

Starts a message move task to redrive messages from a dead-letter queue (DLQ) to the original source queue or a custom destination queue.

```APIDOC
## `startMessageMoveTask`

### Description
Starts a message move task to redrive messages from a dead-letter queue (DLQ) to the original source queue or a custom destination queue.

### Method
`startMessageMoveTask`

### Parameters
- **SourceArn** (`string`) - Required - ARN of the source queue (the DLQ).
- **DestinationArn** (`string|null`) - Optional - ARN of the destination; when `null`, messages are redriven to the original source queue.
- **MaxNumberOfMessagesPerSecond** (`int|null`) - Optional - Message movement rate throttle.
- **'@region'** (`string|null`) - Optional - Per-request region override.

### Request Example
```php
use AsyncAws\Sqs\Input\StartMessageMoveTaskRequest;

$input = new StartMessageMoveTaskRequest([
    'SourceArn' => 'arn:aws:sqs:us-east-1:123456789012:orders-dlq',
    'DestinationArn' => 'arn:aws:sqs:us-east-1:123456789012:orders',
    'MaxNumberOfMessagesPerSecond' => 5,
]);
$taskHandle = $sqs->startMessageMoveTask($input)->getTaskHandle();
```

### Response
- **StartMessageMoveTaskResult** - `getTaskHandle(): ?string`

### Error Handling
Throws: `InvalidAddressException`, `InvalidSecurityException`, `RequestThrottledException`, `ResourceNotFoundException`, `UnsupportedOperationException`.

```php
use AsyncAws\Sqs\Exception\ResourceNotFoundException;

try {
    $sqs->startMessageMoveTask(['SourceArn' => $arn])->getTaskHandle();
} catch (ResourceNotFoundException $e) {
    // source/destination ARN not found
}
```
```

--------------------------------

### GetQueueAttributesRequest usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-queue-lifecycle.md

Example usage of GetQueueAttributesRequest. Creates an input with QueueUrl and AttributeNames set to QueueAttributeName::ALL, then calls getQueueAttributes and retrieves the attributes.

```php
use AsyncAws\Sqs\Enum\QueueAttributeName;

$input = new GetQueueAttributesRequest([
    'QueueUrl' => $url,
    'AttributeNames' => [QueueAttributeName::ALL],
]);
$attributes = $sqs->getQueueAttributes($input)->getAttributes();
```

--------------------------------

### Cancel message move task example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-misc.md

Example usage of cancelMessageMoveTask with a CancelMessageMoveTaskRequest. The TaskHandle field is required.

```php
$sqs->cancelMessageMoveTask((new CancelMessageMoveTaskRequest())->setTaskHandle($handle))->getApproximateNumberOfMessagesMoved();
```

--------------------------------

### Manual pagination with NextToken

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-pagination.md

Manual pagination example. It retrieves the first page with MaxResults, extracts only the current page's URLs, and then uses the NextToken to fetch the next page if available.

```php
$page = $sqs->listQueues(['MaxResults' => 100]);
$urls = iterator_to_array($page->getQueueUrls(true)); // current page only
$nextPageToken = $page->getNextToken();
if (null !== $nextPageToken) {
    $page2 = $sqs->listQueues(['NextToken' => $nextPageToken, 'MaxResults' => 100]);
}
```

--------------------------------

### ListQueuesRequest usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-queue-lifecycle.md

Creates a ListQueuesRequest with a queue name prefix and max results, then iterates over the returned queue URLs.

```php
$input = (new ListQueuesRequest())
    ->setQueueNamePrefix('orders')
    ->setMaxResults(100);
foreach ($sqs->listQueues($input) as $queueUrl) {
    // ...
}
```

--------------------------------

### Retrieve queue attributes example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-management.md

Example call to getQueueAttributes that retrieves all attributes and casts the approximate number of messages to an integer. The QueueUrl is required; AttributeNames is omitted so all attributes are returned.

```php
$attrs = $sqs->getQueueAttributes(['QueueUrl' => $url])->getAttributes();
$available = (int) $attrs[QueueAttributeName::APPROXIMATE_NUMBER_OF_MESSAGES];
```

--------------------------------

### Pagination with listDeadLetterSourceQueues

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-ops.md

Manual pagination example. Uses MaxResults to set page size and NextToken to fetch subsequent pages. The wire field for the page payload is queueUrls (lowercase).

```php
$page = $sqs->listDeadLetterSourceQueues(['QueueUrl' => $dlqUrl, 'MaxResults' => 100]);
while (true) {
    foreach ($page->getQueueUrls(true) as $url) {
        // process current page
    }
    $next = $page->getNextToken();
    if (null === $next) {
        break;
    }
    $page = $sqs->listDeadLetterSourceQueues(['QueueUrl' => $dlqUrl, 'NextToken' => $next, 'MaxResults' => 100]);
}

```

--------------------------------

### Handle ResourceNotFoundException for startMessageMoveTask

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-message-move-tasks.md

Handles ResourceNotFoundException when starting a message move task, which occurs if the source or destination ARN is not found.

```php
use AsyncAws\Sqs\Exception\ResourceNotFoundException;

try {
    $sqs->startMessageMoveTask(['SourceArn' => $arn])->getTaskHandle();
} catch (ResourceNotFoundException $e) {
    // source/destination ARN not found
}
```

--------------------------------

### ReceiveMessageRequest usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-send-receive.md

Shows how to create a ReceiveMessageRequest with queue URL, max messages, wait time, visibility timeout, and message system attribute names, then receive messages.

```php
use AsyncAws\Sqs\Enum\MessageSystemAttributeName;

$input = (new ReceiveMessageRequest())
    ->setQueueUrl($url)
    ->setMaxNumberOfMessages(10)
    ->setWaitTimeSeconds(20)
    ->setVisibilityTimeout(60)
    ->setMessageSystemAttributeNames([MessageSystemAttributeName::APPROXIMATE_RECEIVE_COUNT, MessageSystemAttributeName::SENT_TIMESTAMP]);
$messages = $sqs->receiveMessage($input)->getMessages();
```

--------------------------------

### GetQueueUrlRequest usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-queue-lifecycle.md

Creates a GetQueueUrlRequest with QueueName and QueueOwnerAWSAccountId, then calls getQueueUrl() to retrieve the queue URL.

```php
$input = new GetQueueUrlRequest(['QueueName' => 'orders', 'QueueOwnerAWSAccountId' => '999988887777']);
$url = $sqs->getQueueUrl($input)->getQueueUrl();
```

--------------------------------

### Start a message move task with StartMessageMoveTaskRequest

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-message-move-tasks.md

Creates a message move task to redrive messages from a DLQ to a destination queue. The DestinationArn is optional; when null, messages go to the original source queue. Returns a task handle via getTaskHandle().

```php
use AsyncAws\Sqs\Input\StartMessageMoveTaskRequest;

$input = new StartMessageMoveTaskRequest([
    'SourceArn' => 'arn:aws:sqs:us-east-1:123456789012:orders-dlq',
    'DestinationArn' => 'arn:aws:sqs:us-east-1:123456789012:orders',
    'MaxNumberOfMessagesPerSecond' => 5,
]);
$taskHandle = $sqs->startMessageMoveTask($input)->getTaskHandle();
```

--------------------------------

### Send message batch and inspect results

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-batch.md

Example of sending a batch of messages and iterating over successful and failed entries. The entry-level Id ties each item back to the request entry.

```php
$result = $sqs->sendMessageBatch(['QueueUrl' => $url, 'Entries' => $entries]);
foreach ($result->getSuccessful() as $ok) {
    echo $ok->getId(), ' => ', $ok->getMessageId();
}
foreach ($result->getFailed() as $err) {
    echo $err->getId(), ': ', $err->getCode(), ' (', $err->getMessage(), ') senderFault=', $err->getSenderFault();
}
```

--------------------------------

### deleteMessageBatch usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-messaging.md

Example call to delete multiple messages in a batch. Passes an array with QueueUrl and Entries containing Id and ReceiptHandle pairs. Checks the result's getFailed() count to determine if all deletions succeeded.

```php
$result = $sqs->deleteMessageBatch([
    'QueueUrl' => $url,
    'Entries' => [['Id' => 'x1', 'ReceiptHandle' => $h1], ['Id' => 'x2', 'ReceiptHandle' => $h2]],
]);
if (0 === count($result->getFailed())) {
    // all deleted
}
```

--------------------------------

### DeleteMessageBatchRequestEntry usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/value-objects-batch.md

Creates DeleteMessageBatchRequestEntry objects for each message and calls deleteMessageBatch on the SQS client. The example uses getMessageId() and getReceiptHandle() from each message to populate the required fields.

```php
$deletes = [];
foreach ($messages as $m) {
    $deletes[] = new DeleteMessageBatchRequestEntry(['Id' => $m->getMessageId(), 'ReceiptHandle' => $m->getReceiptHandle()]);
}
$sqs->deleteMessageBatch(['QueueUrl' => $url, 'Entries' => $deletes])->resolve();
```

--------------------------------

### Basic usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-messaging.md

Calls changeMessageVisibility with a visibility timeout of 0 seconds to make the message immediately visible again. The resolve() method is used to execute the request.

```php
$sqs->changeMessageVisibility(['QueueUrl' => $url, 'ReceiptHandle' => $h, 'VisibilityTimeout' => 0])->resolve(); // make it immediately visible again
```

--------------------------------

### SqsClient::startMessageMoveTask

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/README.md

Starts an asynchronous task to move messages from a specified source queue to a specified destination queue. This is useful for migrating messages between queues.

```APIDOC
## SqsClient::startMessageMoveTask

### Description
Starts an asynchronous task to move messages from a specified source queue to a specified destination queue.

### Method
POST

### Endpoint
/

### Parameters
#### Request Body
- **SourceArn** (string) - Required - The ARN of the queue that contains the messages to be moved.
- **DestinationArn** (string) - Optional - The ARN of the queue that receives the moved messages.
- **MaxNumberOfMessagesPerSecond** (integer) - Optional - The maximum number of messages to move per second.

### Request Example
{
  "SourceArn": "arn:aws:sqs:us-east-1:123456789012:MyQueue",
  "DestinationArn": "arn:aws:sqs:us-east-1:123456789012:MyDestinationQueue"
}

### Response
#### Success Response (200)
- **TaskHandle** (string) - An identifier for the message movement task.

#### Response Example
{
  "TaskHandle": "task-123"
}
```

--------------------------------

### Generic Result usage with deleteQueue

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-core.md

Shows how to use the generic AsyncAws\Core\Result returned by operations like deleteQueue. Use resolve() to wait for completion and info() to get the HTTP status.

```php
$result = $sqs->deleteQueue(['QueueUrl' => $url]);
$result->resolve();                      // wait for completion
$status = $result->info()['status'];     // e.g. 200, as used in tests/Integration
```

--------------------------------

### DeleteQueueRequest usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-queue-lifecycle.md

Creates a DeleteQueueRequest with a queue URL and calls deleteQueue() to delete the queue, resolving the promise.

```php
$input = (new DeleteQueueRequest())->setQueueUrl($url);
$sqs->deleteQueue($input)->resolve();
```

--------------------------------

### Delete message batch and count results

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-batch.md

Example of deleting a batch of messages and printing the count of successful and failed deletions.

```php
$result = $sqs->deleteMessageBatch(['QueueUrl' => $url, 'Entries' => $entries]);
echo count($result->getSuccessful()), ' deleted, ', count($result->getFailed()), ' failed';
```

--------------------------------

### Send system attribute with AWSTraceHeader

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/value-objects-messages.md

Example of sending a system attribute with an AWSTraceHeader value. Only AWSTraceHeader is a valid attribute name for MessageSystemAttributes.

```php
use AsyncAws\Sqs\ValueObject\MessageSystemAttributeValue;

$sqs->sendMessage([
    'QueueUrl' => $url,
    'MessageBody' => 'x',
    'MessageSystemAttributes' => [
        'AWSTraceHeader' => new MessageSystemAttributeValue(['DataType' => 'String', 'StringValue' => $xrayHeader]),
    ],
])->resolve();
```

--------------------------------

### Iterate over ListMessageMoveTasksResultEntry results

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/value-objects-batch.md

Example of iterating over the results from ListMessageMoveTasksResult::getResults() and echoing task properties. Note: getStartedTimestamp() is used in the echo but is not defined in the class definition above.

```php
foreach ($result->getResults() as $task) {
    echo $task->getTaskHandle(), $task->getStatus(), $task->getStartedTimestamp();
}
```

--------------------------------

### ChangeMessageVisibilityBatchRequestEntry usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/value-objects-batch.md

Creates a ChangeMessageVisibilityBatchRequestEntry with VisibilityTimeout set to 0 and calls changeMessageVisibilityBatch on the SQS client, then retrieves the successful results.

```php
$entries = [new ChangeMessageVisibilityBatchRequestEntry(['Id' => 'v1', 'ReceiptHandle' => $h, 'VisibilityTimeout' => 0])];
$sqs->changeMessageVisibilityBatch(['QueueUrl' => $url, 'Entries' => $entries])->getSuccessful();
```

--------------------------------

### Change message visibility batch and log failures

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-batch.md

Example of changing visibility timeout for a batch of messages and logging any failed entries with their error codes.

```php
$result = $sqs->changeMessageVisibilityBatch(['QueueUrl' => $url, 'Entries' => $entries]);
if (0 < count($result->getFailed())) {
    foreach ($result->getFailed() as $err) {
        error_log('entry ' . $err->getId() . ' failed: ' . $err->getCode());
    }
}
```

--------------------------------

### Send a message and access result fields

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-batch.md

Example of sending a message and accessing the result's message ID and sequence number. The sequence number is only available for FIFO queues.

```php
$result = $sqs->sendMessage(['QueueUrl' => $url, 'MessageBody' => 'hello']);
echo $result->getMessageId();
echo $result->getSequenceNumber(); // FIFO queues only
```

--------------------------------

### Receive messages and iterate over Message objects

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-batch.md

Example of retrieving messages from an SQS queue using receiveMessage() and iterating over the returned Message objects. The getReceiptHandle() is needed to delete the message later.

```php
$messages = $sqs->receiveMessage(['QueueUrl' => $url, 'MaxNumberOfMessages' => 1])->getMessages();
foreach ($messages as $message) {
    echo $message->getMessageId(), $message->getBody();
    echo $message->getReceiptHandle(); // needed to delete the message
    foreach ($message->getAttributes() as $name => $value) {
        echo $name, '=', $value;
    }
}
```

--------------------------------

### Accessing Message fields

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/value-objects-messages.md

Example usage of the Message value object. Accesses body, system attributes (with fallback), and message attributes (with null-safe access).

```php
$message = $messages[0];
echo $message->getBody();
echo $message->getAttributes()[MessageSystemAttributeName::APPROXIMATE_RECEIVE_COUNT] ?? '0';
echo $message->getMessageAttributes()['kind']?->getStringValue() ?? '';
```

--------------------------------

### SendMessageBatchRequestEntry usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/value-objects-batch.md

Constructs a SendMessageBatchRequestEntry with required Id and MessageBody, plus optional MessageGroupId and MessageDeduplicationId, then sends it via sendMessageBatch. Missing required fields throw InvalidArgument.

```php
use AsyncAws\Sqs\ValueObject\SendMessageBatchRequestEntry;

$entry = new SendMessageBatchRequestEntry([
    'Id' => 'order-1',
    'MessageBody' => '{"id":1}',
    'MessageGroupId' => 'tenant-9',
    'MessageDeduplicationId' => 'order-1',
]);
$sqs->sendMessageBatch(['QueueUrl' => $url, 'Entries' => [$entry]])->resolve();
```

--------------------------------

### deleteQueue method signature and usage

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-management.md

The deleteQueue method signature and a usage example. The method requires the QueueUrl parameter and returns a generic Result. The delete operation uses the HTTP GET verb and can throw InvalidAddressException, InvalidSecurityException, QueueDoesNotExistException, RequestThrottledException, or UnsupportedOperationException.

```php
/**
 * @param array{
 *   QueueUrl: string,
 *   '@region'?: string|null,
 * }|DeleteQueueRequest $input
 */
public function deleteQueue($input): Result
```

```php
$sqs->deleteQueue(['QueueUrl' => $url])->resolve();
```

--------------------------------

### Create a queue with AsyncAws SqsClient

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client.md

Shows how to instantiate the SqsClient and create a queue using the array input form. Credentials are resolved automatically from the environment by the Core package. The getQueueUrl() call blocks until the request completes.

```php
use AsyncAws\Sqs\SqsClient;

$sqs = new SqsClient(); // credentials resolved by Core from the environment

// Array input form
$result = $sqs->createQueue([
    'QueueName' => 'orders',
    'Attributes' => ['VisibilityTimeout' => '30'],
]);

$queueUrl = $result->getQueueUrl(); // blocks until the request completes
```

--------------------------------

### Create SqsClient with endpoint and NullProvider

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/configuration.md

Instantiate the SqsClient with a configuration array and a credentials provider. The endpoint key points to a local fake-SQS endpoint, and NullProvider is used for SigV4 signing in the integration test.

```php
use AsyncAws\Sqs\SqsClient;
use AsyncAws\Core\Credentials\NullProvider;

$client = new SqsClient([
    'endpoint' => 'http://localhost:9494', // local fake-SQS endpoint
], new NullProvider());
```

--------------------------------

### SqsClient

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client.md

Documentation for the SqsClient class, including its constructor and usage patterns.

```APIDOC
## SqsClient

### Description
`SqsClient` is the single public entry point of the library. It is a final API client for the Amazon SQS service, generated by the AsyncAws SDK generator and communicating with SQS through the Amazon SQS JSON-1.0 protocol (`application/x-amz-json-1.0`). It extends `AsyncAws\Core\AbstractApi`.

### Class Signature
```php
class SqsClient extends AbstractApi
```

### Constructor
`SqsClient` declares no constructor of its own — it uses the constructor inherited from `AsyncAws\Core\AbstractApi`. The constructor accepts the following parameters:

#### Parameters
- **$configuration** (`AsyncAws\Core\Configuration`) - Required - Configuration passed as an associative array. The only key exercised in this repository is `'endpoint'`; region resolution flows through `Configuration`.
- **$credentialProvider** (`AsyncAws\Core\Credentials\Provider`) - Optional - A Core credentials provider. If omitted, Core supplies its default provider chain.

#### Example
```php
new SqsClient([
    'endpoint' => 'http://localhost:9494',
], new NullProvider());
```

### Usage
Every public operation takes a single `$input` argument that is either an associative array or an `AsyncAws\Sqs\Input\*Request` object. The array form is a map whose keys are the PascalCase AWS parameter names, plus an optional `'@region' => string|null` key that overrides the region used for this single request. The request objects additionally expose fluent setters and getters.

All methods are asynchronous by construction: they return a `Result` (or a subclass of `AsyncAws\Core\Result`) immediately, and the HTTP call is dispatched in the background by AsyncAws Core. The HTTP response is only consumed when the result is resolved — lazily, on the first getter call — or explicitly via `resolve()`.
```

--------------------------------

### deleteMessage usage example

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-messaging.md

Example call to delete a single message using the deleteMessage method. Passes an array with QueueUrl and ReceiptHandle, then resolves the returned promise.

```php
$sqs->deleteMessage(['QueueUrl' => $url, 'ReceiptHandle' => $handle])->resolve();
```

--------------------------------

### Error handling for startMessageMoveTask

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-move-tasks.md

Catches ResourceNotFoundException when the source/destination ARN does not exist and InvalidSecurityException when credentials lack the sqs:StartMessageMoveTask permission.

```php
use AsyncAws\Sqs\Exception\ResourceNotFoundException;
use AsyncAws\Sqs\Exception\InvalidSecurityException;

try {
    $sqs->startMessageMoveTask(['SourceArn' => $sourceArn])->getTaskHandle();
} catch (ResourceNotFoundException $e) {
    // source/destination ARN does not exist
} catch (InvalidSecurityException $e) {
    // credentials lack sqs:StartMessageMoveTask permission
}
```

--------------------------------

### getQueueUrl error handling

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-management.md

Shows how to catch QueueDoesNotExistException when the queue does not exist, with a comment to create the queue first.

```php
use AsyncAws\Sqs\Exception\QueueDoesNotExistException;

try {
    $url = $sqs->getQueueUrl(['QueueName' => 'orders'])->getQueueUrl();
} catch (QueueDoesNotExistException $e) {
    // create the queue first
}

```

--------------------------------

### getQueueAttributes($input)

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client.md

Gets attributes for a specified queue. The input is a GetQueueAttributesRequest object or an array of parameters.

```APIDOC
## getQueueAttributes($input)

### Description
Gets attributes for a specified queue. The input is a GetQueueAttributesRequest object or an array of parameters.

### Method
getQueueAttributes

### Parameters
- **$input** (GetQueueAttributesRequest|array) - Required - The request object or array of parameters for the GetQueueAttributes operation.

### Return Type
GetQueueAttributesResult

### Source
src/SqsClient.php:542
```

--------------------------------

### SqsClient::getQueueAttributes

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/README.md

Gets attributes for the specified queue. You can request all attributes or a specific set of attributes.

```APIDOC
## SqsClient::getQueueAttributes

### Description
Gets attributes for the specified queue.

### Method
POST

### Endpoint
/

### Parameters
#### Request Body
- **QueueUrl** (string) - Required - The URL of the queue.
- **AttributeNames** (array of strings) - Required - A list of attributes to retrieve.

### Request Example
{
  "QueueUrl": "https://sqs.us-east-1.amazonaws.com/123456789012/MyQueue",
  "AttributeNames": ["All"]
}

### Response
#### Success Response (200)
- **Attributes** (array) - A map of attributes to their values.

#### Response Example
{
  "Attributes": {
    "QueueArn": "arn:aws:sqs:us-east-1:123456789012:MyQueue",
    "ApproximateNumberOfMessages": "0"
  }
}
```

--------------------------------

### listDeadLetterSourceQueues

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-ops.md

Documentation for the listDeadLetterSourceQueues method of the SqsClient class, including parameters, return type, exceptions, and usage examples.

```APIDOC
## listDeadLetterSourceQueues

### Description
Lists the source queues that have a redrive policy pointing to the specified dead-letter queue. The result is paginated and iterable.

### Method
listDeadLetterSourceQueues

### Endpoint
SqsClient::listDeadLetterSourceQueues

### Parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `QueueUrl` | `string` | yes | — | The dead-letter queue; returns queues whose `RedrivePolicy` points at it. |
| `NextToken` | `string\|null` | no | `null` | Pagination token from a previous response. |
| `MaxResults` | `int\|null` | no | `null` | Page size; responses default to 1,000 results. |
| `'@region'` | `string\|null` | no | `null` | Per-request region override. |

### Return
`ListDeadLetterSourceQueuesResult` (paginated, iterable).

### Throws
`InvalidAddressException`, `InvalidSecurityException`, `QueueDoesNotExistException`, `RequestThrottledException`, `UnsupportedOperationException`.

### Request Example
```php
$dlqUrl = 'https://sqs.us-east-1.amazonaws.com/123456789012/orders-dlq';
foreach ($sqs->listDeadLetterSourceQueues(['QueueUrl' => $dlqUrl]) as $sourceUrl) {
    echo $sourceUrl;
}
```

### Pagination Example
```php
$page = $sqs->listDeadLetterSourceQueues(['QueueUrl' => $dlqUrl, 'MaxResults' => 100]);
while (true) {
    foreach ($page->getQueueUrls(true) as $url) {
        // process current page
    }
    $next = $page->getNextToken();
    if (null === $next) {
        break;
    }
    $page = $sqs->listDeadLetterSourceQueues(['QueueUrl' => $dlqUrl, 'NextToken' => $next, 'MaxResults' => 100]);
}
```

### Note
The wire field for the page payload is `queueUrls` (lowercase).
```

--------------------------------

### createQueue

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-management.md

Documentation for the createQueue operation of the SqsClient.

```APIDOC
## createQueue

### Description
Creates a new queue with the specified name and optional attributes and tags. Returns a lazily-resolved result containing the queue URL.

### Method
createQueue

### Parameters
- **QueueName** (string) - Required - New queue name: up to 80 chars, alphanumeric, `-` and `_`; FIFO names end with `.fifo`.
- **Attributes** (array<QueueAttributeName::*, string>) - Optional - Queue attributes keyed by `QueueAttributeName` constants.
- **tags** (array<string, string>) - Optional - Cost-allocation tags (max ~50 recommended).
- **'@region'** (string|null) - Optional - Per-request region override.

### Return
`CreateQueueResult` — lazily-resolved queue `QueueUrl` (`getQueueUrl(): ?string`).

### Exceptions
Throws (mapped from server error codes): `InvalidAddressException`, `InvalidAttributeNameException`, `InvalidAttributeValueException`, `InvalidSecurityException`, `QueueDeletedRecentlyException`, `QueueNameExistsException`, `RequestThrottledException`, `UnsupportedOperationException`. Client-side, `AsyncAws\Core\Exception\InvalidArgument` is thrown if `QueueName` is missing or an `Attributes` key is not a valid `QueueAttributeName`.

### Request Example
```php
$sqs->createQueue(['QueueName' => 'orders.fifo', 'Attributes' => [
    QueueAttributeName::FIFO_QUEUE => 'true',
    QueueAttributeName::MESSAGE_RETENTION_PERIOD => '604800',
], 'tags' => ['team' => 'billing']])->getQueueUrl();
```

### Error Handling Example
```php
use AsyncAws\Sqs\Exception\QueueNameExistsException;

try {
    $result = $sqs->createQueue(['QueueName' => 'orders']);
} catch (QueueNameExistsException $e) {
    // A queue with this name exists with different attributes
}
```
```

--------------------------------

### StartMessageMoveTaskRequest class signature

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-misc.md

Class signature for StartMessageMoveTaskRequest, showing the constructor, factory, getters, setters, and request method. SourceArn is required; DestinationArn and MaxNumberOfMessagesPerSecond are optional.

```php
final class StartMessageMoveTaskRequest extends Input
public function __construct(array $input = [])
public static function create($input): self
public function getSourceArn(): ?string
public function getDestinationArn(): ?string
public function getMaxNumberOfMessagesPerSecond(): ?int
public function setSourceArn(?string $value): self
public function setDestinationArn(?string $value): self
public function setMaxNumberOfMessagesPerSecond(?int $value): self
public function request(): Request
```

--------------------------------

### deleteQueue

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-management.md

Deletes a queue by URL. The operation takes up to 60 seconds to complete and uses the HTTP GET verb.

```APIDOC
## deleteQueue

### Description
Deletes the specified queue. The deletion process takes up to 60 seconds. This operation uses the HTTP GET verb.

### Method
DELETE

### Endpoint
`deleteQueue`

### Parameters
#### Request Body
- **QueueUrl** (string) - Required - URL of the queue to delete.
- **'@region'** (string|null) - Optional - Per-request region override.

### Request Example
```php
$sqs->deleteQueue(['QueueUrl' => $url])->resolve();
```

### Response
#### Success Response (200)
- **Result** - Generic result object.

#### Response Example
```php
$result = $sqs->deleteQueue(['QueueUrl' => $url])->resolve();
```

### Error Handling
Throws: `InvalidAddressException`, `InvalidSecurityException`, `QueueDoesNotExistException`, `RequestThrottledException`, `UnsupportedOperationException`.
```

--------------------------------

### queueExists basic call

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-management.md

Creates a queue, then waits for it to exist. The wait() method returns true when the queue is visible and usable.

```php
$sqs->createQueue(['QueueName' => 'orders'])->resolve();
if ($sqs->queueExists(['QueueName' => 'orders'])->wait()) {
    // queue is visible and usable
}

```

--------------------------------

### List message move tasks and process results

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-move-tasks.md

Lists up to 10 move tasks for a source queue and iterates over the results, printing the task handle and failure reason for FAILED tasks or the moved count for RUNNING tasks.

```php
$tasks = $sqs->listMessageMoveTasks([
    'SourceArn' => 'arn:aws:sqs:us-east-1:123456789012:orders-dlq',
    'MaxResults' => 10,
])->getResults();

foreach ($tasks as $task) {
    $status = $task->getStatus();
    if ('FAILED' === $status) {
        echo $task->getTaskHandle(), ' failed: ', $task->getFailureReason();
    } elseif ('RUNNING' === $status) {
        echo $task->getTaskHandle(), ' moved ', $task->getApproximateNumberOfMessagesMoved();
    }
}
```

--------------------------------

### Basic createQueue call with FIFO attributes

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-management.md

Basic call to create a FIFO queue with attributes and tags, then retrieve the queue URL. Uses QueueAttributeName constants for FIFO_QUEUE and MESSAGE_RETENTION_PERIOD.

```php
$sqs->createQueue(['QueueName' => 'orders.fifo', 'Attributes' => [
    QueueAttributeName::FIFO_QUEUE => 'true',
    QueueAttributeName::MESSAGE_RETENTION_PERIOD => '604800',
], 'tags' => ['team' => 'billing']])->getQueueUrl();
```

--------------------------------

### Send binary message attribute

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/value-objects-messages.md

Example of creating a MessageAttributeValue with binary data and sending it as a message attribute. The BinaryValue is base64-encoded during serialization.

```php
use AsyncAws\Sqs\ValueObject\MessageAttributeValue;

$attr = new MessageAttributeValue(['DataType' => 'Binary', 'BinaryValue' => "\x00\x01"]);
$sqs->sendMessage(['QueueUrl' => $url, 'MessageBody' => 'x', 'MessageAttributes' => ['blob' => $attr]])->resolve();
```

--------------------------------

### Handle InvalidAttributeNameException

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-queue-management.md

Error handling example for getQueueAttributes. Catches InvalidAttributeNameException when the server rejects an attribute name. Requires importing the exception class.

```php
use AsyncAws\Sqs\Exception\InvalidAttributeNameException;

try {
    $sqs->getQueueAttributes(['QueueUrl' => $url, 'AttributeNames' => ['BogusName']]);
} catch (InvalidAttributeNameException $e) {
    // server rejected the attribute name
}
```

--------------------------------

### createQueue($input)

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client.md

Creates a new standard or FIFO queue. The input is a CreateQueueRequest object or an array of parameters.

```APIDOC
## createQueue($input)

### Description
Creates a new standard or FIFO queue. The input is a CreateQueueRequest object or an array of parameters.

### Method
createQueue

### Parameters
- **$input** (CreateQueueRequest|array) - Required - The request object or array of parameters for the CreateQueue operation.

### Return Type
CreateQueueResult

### Source
src/SqsClient.php:360
```

--------------------------------

### DeleteQueueRequest class definition

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/inputs-queue-lifecycle.md

Defines the DeleteQueueRequest input class with methods for getting and setting QueueUrl. QueueUrl is required in requestBody() (line 84).

```php
final class DeleteQueueRequest extends Input
public function __construct(array $input = [])
public static function create($input): self
public function getQueueUrl(): ?string
public function setQueueUrl(?string $value): self
public function request(): Request
```

--------------------------------

### listMessageMoveTasks($input)

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client.md

Lists message move tasks for a queue. The input is a ListMessageMoveTasksRequest object or an array of parameters.

```APIDOC
## listMessageMoveTasks($input)

### Description
Lists message move tasks for a queue. The input is a ListMessageMoveTasksRequest object or an array of parameters.

### Method
listMessageMoveTasks

### Parameters
- **$input** (ListMessageMoveTasksRequest|array) - Required - The request object or array of parameters for the ListMessageMoveTasks operation.

### Return Type
ListMessageMoveTasksResult

### Source
src/SqsClient.php:667
```

--------------------------------

### Wait for queue existence

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-pagination.md

Waits for a queue to exist after creation. It creates the queue, then uses the queueExists waiter with a 10-second timeout. If the waiter succeeds, it retrieves the queue URL.

```php
$sqs->createQueue(['QueueName' => 'orders'])->resolve();
$waiter = $sqs->queueExists(['QueueName' => 'orders']);
$exists = $waiter->wait(10.0); // poll up to 10 seconds
if ($waiter->isSuccess()) {
    $url = $sqs->getQueueUrl(['QueueName' => 'orders'])->getQueueUrl();
}
```

--------------------------------

### receiveMessage with error handling

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/sqs-client-messaging.md

Example of receiving a single message with long polling and deleting it after processing. Catches OverLimitException when the queue's in-flight limit is reached.

```php
use AsyncAws\Sqs\Exception\OverLimitException;

try {
    $message = $sqs->receiveMessage(['QueueUrl' => $url, 'MaxNumberOfMessages' => 1])->getMessages()[0] ?? null;
    if (null !== $message) {
        $sqs->deleteMessage(['QueueUrl' => $url, 'ReceiptHandle' => $message->getReceiptHandle()])->resolve();
    }
} catch (OverLimitException $e) {
    // too many in-flight messages for the queue
}
```

--------------------------------

### Iterate all queue URLs with pagination

Source: https://github.com/async-aws/sqs/blob/master/_autodocs/api-reference/results-pagination.md

Basic usage iterating over all pages of queue URLs. The result object is iterable because it implements IteratorAggregate, and it prefetches subsequent pages as you iterate.

```php
foreach ($sqs->listQueues() as $queueUrl) {
    echo $queueUrl;
}
```
Tokens:
Raw