# Queues (/sdks/rust/reference/queues)



## QueueMessage [#queuemessage]

A message for the point-to-point queue pattern. Messages are persisted and delivered to exactly one consumer.

| Field        | Type                             | Description                                      |
| ------------ | -------------------------------- | ------------------------------------------------ |
| `id`         | `String`                         | Message ID (auto-generated UUID v4 when empty)   |
| `client_id`  | `String`                         | Sender identity override                         |
| `channel`    | `String`                         | Target queue channel name (required)             |
| `metadata`   | `String`                         | Optional UTF-8 metadata                          |
| `body`       | `Vec<u8>`                        | Message payload bytes                            |
| `tags`       | `HashMap<String, String>`        | Arbitrary key-value pairs                        |
| `policy`     | `Option<QueuePolicy>`            | Delivery policy (expiration, delay, dead-letter) |
| `attributes` | `Option<QueueMessageAttributes>` | Server-assigned attributes (receive only)        |

### Builder [#builder]

```rust title="main.rs"
let msg = QueueMessage::builder()
    .channel("tasks")
    .body(b"process-order-42".to_vec())
    .expiration_seconds(300)
    .max_receive_count(3)
    .max_receive_queue("tasks.dead-letter")
    .build();
```

## QueuePolicy [#queuepolicy]

Controls expiration, delayed delivery, and dead-letter routing.

| Field                | Type     | Default | Description                                              |
| -------------------- | -------- | ------- | -------------------------------------------------------- |
| `expiration_seconds` | `i32`    | 0       | Seconds until message expires (0 = no expiration)        |
| `delay_seconds`      | `i32`    | 0       | Seconds to delay before visible (0 = immediate)          |
| `max_receive_count`  | `i32`    | 0       | Max delivery attempts before dead-letter (0 = unlimited) |
| `max_receive_queue`  | `String` | `""`    | Dead-letter queue channel                                |

## QueueSendResult [#queuesendresult]

Returned by `send_queue_message`.

| Field           | Type     | Description                             |
| --------------- | -------- | --------------------------------------- |
| `message_id`    | `String` | Server-assigned message identifier      |
| `sent_at`       | `i64`    | Acceptance timestamp (Unix nanoseconds) |
| `expiration_at` | `i64`    | Expiration timestamp                    |
| `delayed_to`    | `i64`    | Delay-until timestamp                   |
| `is_error`      | `bool`   | Whether the server reported an error    |
| `error`         | `String` | Error message when `is_error` is `true` |

## QueueMessageAttributes [#queuemessageattributes]

Server-assigned attributes on received messages.

| Field                  | Type     | Description                               |
| ---------------------- | -------- | ----------------------------------------- |
| `timestamp`            | `i64`    | Enqueue timestamp (Unix nanoseconds)      |
| `sequence`             | `u64`    | Monotonic sequence within the queue       |
| `md5_of_body`          | `String` | MD5 hash of the message body              |
| `receive_count`        | `i32`    | Number of deliveries (including current)  |
| `re_routed`            | `bool`   | Whether re-routed from another queue      |
| `re_routed_from_queue` | `String` | Original queue when `re_routed` is `true` |
| `expiration_at`        | `i64`    | Expiration timestamp                      |
| `delayed_to`           | `i64`    | Delay-until timestamp                     |

## Client Methods [#client-methods]

### send\_queue\_message [#send_queue_message]

```rust title="main.rs"
let result = client.send_queue_message(msg).await?;
println!("Sent: {}", result.message_id);
```

### send\_queue\_messages [#send_queue_messages]

Batch send multiple messages.

```rust title="main.rs"
let results = client.send_queue_messages(vec![msg1, msg2]).await?;
```

### receive\_queue\_messages [#receive_queue_messages]

Pull messages from a queue.

```rust title="main.rs"
let messages = client.receive_queue_messages("tasks", 10, 5, false).await?;
```

### ack\_all\_queue\_messages [#ack_all_queue_messages]

Acknowledge all pending messages.

```rust title="main.rs"
let req = AckAllQueueMessagesRequest {
    request_id: String::new(),
    client_id: String::new(),
    channel: "tasks".to_string(),
    wait_time_seconds: 5,
};
let resp = client.ack_all_queue_messages(&req).await?;
```