> ## Documentation Index
> Fetch the complete documentation index at: https://densumesh-broccoli-27.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Options

> API reference for PublishOptions, ConsumeOptions, and RetryStrategy

## PublishOptions

Options for publishing messages.

```rust theme={null}
use broccoli_queue::queue::PublishOptions;
```

### Structure

```rust theme={null}
pub struct PublishOptions {
    /// Time-to-live for the message
    pub ttl: Option<Duration>,
    
    /// Message priority (1-5, where 1 is highest)
    pub priority: Option<u8>,
    
    /// Delay before the message is published
    pub delay: Option<Duration>,
    
    /// Scheduled time for message delivery
    pub scheduled_at: Option<OffsetDateTime>,
}
```

### Builder

```rust theme={null}
let options = PublishOptions::builder()
    .delay(Duration::seconds(30))
    .priority(1)
    .ttl(Duration::hours(24))
    .build();

queue.publish("jobs", None, &job, Some(options)).await?;
```

### Methods

#### `builder()`

Creates a new `PublishOptionsBuilder`.

```rust theme={null}
pub const fn builder() -> PublishOptionsBuilder
```

***

## PublishOptionsBuilder

Builder for constructing `PublishOptions`.

### `ttl`

Sets the time-to-live for the message.

```rust theme={null}
pub const fn ttl(mut self, duration: Duration) -> Self
```

**Example:**

```rust theme={null}
PublishOptions::builder()
    .ttl(Duration::hours(1))
    .build()
```

### `priority`

Sets the priority level (1-5, where 1 is highest).

```rust theme={null}
pub fn priority(mut self, priority: u8) -> Self
```

**Panics:** If priority is not between 1 and 5.

**Example:**

```rust theme={null}
PublishOptions::builder()
    .priority(1)  // High priority
    .build()
```

### `delay`

Sets a delay before message delivery.

```rust theme={null}
pub const fn delay(mut self, duration: Duration) -> Self
```

**Example:**

```rust theme={null}
PublishOptions::builder()
    .delay(Duration::minutes(5))
    .build()
```

### `schedule_at`

Sets a specific delivery time.

```rust theme={null}
pub const fn schedule_at(mut self, time: OffsetDateTime) -> Self
```

**Example:**

```rust theme={null}
use time::OffsetDateTime;

let tomorrow = OffsetDateTime::now_utc() + Duration::days(1);
PublishOptions::builder()
    .schedule_at(tomorrow)
    .build()
```

### `build`

Builds the `PublishOptions`.

```rust theme={null}
pub const fn build(self) -> PublishOptions
```

***

## ConsumeOptions

Options for consuming messages.

```rust theme={null}
use broccoli_queue::queue::ConsumeOptions;
```

### Structure

```rust theme={null}
pub struct ConsumeOptions {
    /// Auto-acknowledge messages (default: false)
    pub auto_ack: Option<bool>,
    
    /// Enable fairness queue consumption (Redis only)
    pub fairness: Option<bool>,
    
    /// Wait duration between consume iterations
    pub consume_wait: Option<std::time::Duration>,
    
    /// Acknowledge after handler success (default: true)
    pub handler_ack: Option<bool>,
}
```

### Builder

```rust theme={null}
let options = ConsumeOptions::builder()
    .fairness(true)
    .auto_ack(false)
    .build();

queue.process_messages("jobs", Some(4), Some(options), handler).await?;
```

***

## ConsumeOptionsBuilder

Builder for constructing `ConsumeOptions`.

### `auto_ack`

Sets whether messages are auto-acknowledged.

```rust theme={null}
pub const fn auto_ack(mut self, auto_ack: bool) -> Self
```

**Default:** `false`

<Warning>
  If `auto_ack` is true, calling `acknowledge()` or `reject()` will return an error.
</Warning>

### `fairness`

Enables fairness queue consumption (Redis only).

```rust theme={null}
pub const fn fairness(mut self, fairness: bool) -> Self
```

**Example:**

```rust theme={null}
ConsumeOptions::builder()
    .fairness(true)
    .build()
```

### `consume_wait`

Sets the wait duration between consume loop iterations.

```rust theme={null}
pub const fn consume_wait(mut self, consume_wait: std::time::Duration) -> Self
```

This allows consumer loops to be interrupted by tokio.

**Example:**

```rust theme={null}
ConsumeOptions::builder()
    .consume_wait(std::time::Duration::from_millis(10))
    .build()
```

### `handler_ack`

Controls automatic acknowledgment after successful handler execution.

```rust theme={null}
pub const fn handler_ack(mut self, followup: bool) -> Self
```

**Default:** `true`

Set to `false` to manually control acknowledgment:

```rust theme={null}
ConsumeOptions::builder()
    .handler_ack(false)
    .build()
```

### `build`

Builds the `ConsumeOptions`.

```rust theme={null}
pub const fn build(self) -> ConsumeOptions
```

***

## RetryStrategy

Configuration for message retry behavior.

```rust theme={null}
use broccoli_queue::queue::RetryStrategy;
```

### Structure

```rust theme={null}
pub struct RetryStrategy {
    /// Whether failed messages should be retried
    pub retry_failed: bool,
    
    /// Maximum number of retry attempts
    pub attempts: Option<u8>,
}
```

### Default

```rust theme={null}
impl Default for RetryStrategy {
    fn default() -> Self {
        Self {
            retry_failed: true,
            attempts: Some(3),
        }
    }
}
```

### Methods

#### `new`

Creates a new retry strategy with defaults.

```rust theme={null}
pub const fn new() -> Self
```

#### `with_attempts`

Sets the maximum retry attempts.

```rust theme={null}
pub const fn with_attempts(mut self, attempts: u8) -> Self
```

**Example:**

```rust theme={null}
RetryStrategy::new().with_attempts(5)
```

#### `retry_failed`

Enables or disables retrying.

```rust theme={null}
pub const fn retry_failed(mut self, retry_failed: bool) -> Self
```

**Example:**

```rust theme={null}
// Disable retries - failures go directly to failed queue
RetryStrategy::new().retry_failed(false)
```

### Usage

```rust theme={null}
let queue = BroccoliQueue::builder("redis://localhost:6379")
    .failed_message_retry_strategy(
        RetryStrategy::new()
            .with_attempts(5)
            .retry_failed(true)
    )
    .build()
    .await?;
```

***

## QueueStatus (management feature)

Status information for a queue.

```rust theme={null}
#[cfg(feature = "management")]
use broccoli_queue::brokers::management::QueueStatus;
```

### Structure

```rust theme={null}
pub struct QueueStatus {
    pub pending_count: u64,
    pub processing_count: u64,
    pub failed_count: u64,
}
```

### Usage

```rust theme={null}
#[cfg(feature = "management")]
{
    let status = queue.queue_status("jobs".into(), None).await?;
    println!("Pending: {}", status.pending_count);
    println!("Processing: {}", status.processing_count);
    println!("Failed: {}", status.failed_count);
}
```