@amqp-contract/contract 0.20.0 → 0.22.0

package/dist/index.d.cts

@@ -27,6 +27,7 @@ type TtlBackoffRetryOptions = {
   mode: "ttl-backoff";
   /**
    * Maximum retry attempts before sending to DLQ.
+   * @minimum 1 - Must be a positive integer (1 or greater)
    * @default 3
    */
   maxRetries?: number;
@@ -50,27 +51,66 @@ type TtlBackoffRetryOptions = {
    * @default true
    */
   jitter?: boolean;
+  /**
+   * Name of the wait queue.
+   * @default '{queueName}-wait'
+   */
+  waitQueueName?: string;
+  /**
+   * Name of the wait exchange.
+   * @default 'wait-exchange'
+   */
+  waitExchangeName?: string;
+  /**
+   * Name of the retry exchange.
+   * @default 'retry-exchange'
+   */
+  retryExchangeName?: string;
 };
 /**
- * Quorum-Native retry options using RabbitMQ's native delivery limit feature.
+ * Immediate-Requeue retry options.
  *
- * Uses quorum queue's `x-delivery-limit` feature. Messages are requeued immediately
- * with `nack(requeue=true)`, and RabbitMQ tracks delivery count via `x-delivery-count`
- * header. When the count exceeds the queue's `deliveryLimit`, the message is
- * automatically dead-lettered.
+ * Failed messages are requeued immediately.
+ * For quorum queues, messages are requeued with `nack(requeue=true)`, and the worker tracks delivery count via the native RabbitMQ `x-delivery-count` header.
+ * For classic queues, messages are re-published on the same queue, and the worker tracks delivery count via a custom `x-retry-count` header.
+ * When the count exceeds `maxRetries`, the message is automatically dead-lettered (if DLX is configured) or dropped.
  *
  * **Benefits:** Simpler architecture, no wait queues needed, no head-of-queue blocking.
  * **Limitation:** Immediate retries only (no exponential backoff).
  *
  * @see https://www.rabbitmq.com/docs/quorum-queues#poison-message-handling
  */
-type QuorumNativeRetryOptions = {
+type ImmediateRequeueRetryOptions = {
+  /**
+   * Immediate-Requeue mode.
+   */
+  mode: "immediate-requeue";
+  /**
+   * Maximum retry attempts before sending to DLQ.
+   * @minimum 1 - Must be a positive integer (1 or greater)
+   * @default 3
+   */
+  maxRetries?: number;
+};
+/**
+ * No retry mode. Failed messages are not retried and are sent
+ * directly to DLQ (if configured) or rejected.
+ */
+type NoneRetryOptions = {
   /**
-   * Quorum-Native mode uses RabbitMQ's native delivery limit feature.
-   * Requires the queue to be a quorum queue with `deliveryLimit` configured.
+   * None mode disables retry attempts entirely.
    */
-  mode: "quorum-native";
+  mode: "none";
 };
+/**
+ * Retry configuration options.
+ *
+ * This is a discriminated union based on the `mode` field:
+ * - `none` (default): No retry attempts are made; failed messages are handled by DLQ/reject
+ * - `immediate-requeue`: Requeues failed messages immediately
+ * - `ttl-backoff`: Uses wait queues with exponential backoff
+ */
+type RetryOptions = NoneRetryOptions | ImmediateRequeueRetryOptions | TtlBackoffRetryOptions;
 /**
  * Resolved TTL-Backoff retry options with all defaults applied.
  *
@@ -86,15 +126,34 @@ type ResolvedTtlBackoffRetryOptions = {
   maxDelayMs: number;
   backoffMultiplier: number;
   jitter: boolean;
+  waitQueueName: string;
+  waitExchangeName: string;
+  retryExchangeName: string;
+};
+/**
+ * Resolved Immediate-Requeue retry options with all defaults applied.
+ *
+ * This type is used internally in queue definitions after `defineQueue` has applied
+ * default values. All fields are required.
+ *
+ * @internal
+ */
+type ResolvedImmediateRequeueRetryOptions = {
+  mode: "immediate-requeue";
+  maxRetries: number;
 };
 /**
  * Resolved retry configuration stored in queue definitions.
  *
  * This is a discriminated union based on the `mode` field:
- * - `ttl-backoff`: Has all TTL-backoff options with defaults applied
- * - `quorum-native`: No additional options (uses RabbitMQ native retry)
+ * - `none`: No retry attempts are made; failed messages are handled by DLQ/reject
+ * - `immediate-requeue`: Has all immediate-requeue retry options with default applied
+ * - `ttl-backoff`: Has all TTL-backoff retry options with defaults applied
+ *
+ * When using `ttl-backoff` mode, the core package will automatically create
+ * a wait queue and the necessary exchanges and bindings.
  */
-type ResolvedRetryOptions = ResolvedTtlBackoffRetryOptions | QuorumNativeRetryOptions;
+type ResolvedRetryOptions = NoneRetryOptions | ResolvedImmediateRequeueRetryOptions | ResolvedTtlBackoffRetryOptions;
 /**
  * Supported compression algorithms for message payloads.
  *
@@ -132,8 +191,7 @@ type CompressionAlgorithm = "gzip" | "deflate";
  * - `classic`: Classic queues - The traditional RabbitMQ queue type. Use only when you need
  *   specific features not supported by quorum queues (e.g., non-durable queues, priority queues).
  *
- * Note: Quorum queues require `durable: true` and do not support `exclusive: true`.
- * When using quorum queues, `durable` is automatically set to `true`.
+ * Note: Quorum queues only support durable queues, and do not support exclusive, auto-deleting, or priority queues.
  *
  * @see https://www.rabbitmq.com/docs/quorum-queues
  *
@@ -156,21 +214,37 @@ type QueueType = "quorum" | "classic";
  * Common queue options shared between quorum and classic queues.
  */
 type BaseQueueOptions = {
-  /**
-   * If true, the queue survives broker restarts. Durable queues are persisted to disk.
-   * Note: Quorum queues are always durable regardless of this setting.
-   * @default false (but forced to true for quorum queues during setup)
-   */
-  durable?: boolean;
-  /**
-   * If true, the queue is deleted when the last consumer unsubscribes.
-   * @default false
-   */
-  autoDelete?: boolean;
   /**
    * Dead letter configuration for handling failed or rejected messages.
    */
   deadLetter?: DeadLetterConfig;
+  /**
+   * Retry configuration for handling failed message processing.
+   *
+   * @example
+   * ```typescript
+   * // No retry
+   * const orderQueue = defineQueue('order-processing', {
+   *   retry: { mode: 'none' },
+   * });
+   *
+   * // Immediate-requeue mode
+   * const orderQueue = defineQueue('order-processing', {
+   *   retry: { mode: 'immediate-requeue', maxRetries: 5 },
+   * });
+   *
+   * // TTL-backoff mode with custom options
+   * const orderQueue = defineQueue('order-processing', {
+   *   retry: {
+   *     mode: 'ttl-backoff',
+   *     maxRetries: 5,
+   *     initialDelayMs: 1000,
+   *     maxDelayMs: 30000,
+   *   },
+   * });
+   * ```
+   */
+  retry?: RetryOptions;
   /**
    * Additional AMQP arguments for advanced configuration.
    */
@@ -180,12 +254,14 @@ type BaseQueueOptions = {
  * Options for creating a quorum queue.
  *
  * Quorum queues do not support:
- * - `exclusive` - Use classic queues for exclusive access
+ * - `exclusive` - Use classic queues for connection-scoped queues
+ * - `autoDelete` - Use classic queues for auto-deleting queues when consumers disconnect
  * - `maxPriority` - Use classic queues for priority queues
+ * - `durable: false` - Use classic queues for non-durable queues
  *
- * Quorum queues provide native retry support via `deliveryLimit`:
+ * Quorum queues provide native retry support for immediate-requeue retry mode:
  * - RabbitMQ tracks delivery count automatically via `x-delivery-count` header
- * - When the limit is exceeded, messages are dead-lettered (if DLX is configured)
+ * - When the limit is exceeded, messages are dead-lettered (if DLX is configured) or dropped
  * - This is simpler than TTL-based retry and avoids head-of-queue blocking issues
  *
  * @example
@@ -193,7 +269,7 @@ type BaseQueueOptions = {
  * const orderQueue = defineQueue('orders', {
  *   type: 'quorum',
  *   deadLetter: { exchange: dlx },
- *   deliveryLimit: 3, // Message dead-lettered after 3 delivery attempts
+ *   retry: { mode: 'immediate-requeue', maxRetries: 3 } // Message dead-lettered after 3 retry attempts
  * });
  * ```
  */
@@ -202,88 +278,32 @@ type QuorumQueueOptions = BaseQueueOptions & {
    * Queue type: quorum (default, recommended)
    */
   type?: "quorum";
+  /**
+   * Quorum queues only support durable queues.
+   */
+  durable?: true;
   /**
    * Quorum queues do not support exclusive mode.
    * Use type: 'classic' if you need exclusive queues.
    */
   exclusive?: never;
+  /**
+   * Quorum queues do not support auto-delete mode.
+   * Use type: 'classic' if you need auto-deleting queues.
+   */
+  autoDelete?: never;
   /**
    * Quorum queues do not support priority queues.
    * Use type: 'classic' if you need priority queues.
    */
   maxPriority?: never;
-  /**
-   * Maximum number of delivery attempts before the message is dead-lettered.
-   *
-   * When a message is rejected (nacked) and requeued, RabbitMQ increments
-   * the `x-delivery-count` header. When this count reaches the delivery limit,
-   * the message is automatically dead-lettered (if DLX is configured) or dropped.
-   *
-   * This is a quorum queue-specific feature that provides native retry handling
-   * without the complexity of TTL-based wait queues.
-   *
-   * **Benefits over TTL-based retry:**
-   * - Simpler architecture (no wait queues needed)
-   * - No head-of-queue blocking issues (TTL only works at queue head)
-   * - Native RabbitMQ feature with atomic guarantees
-   *
-   * @minimum 1 - Must be a positive integer (1 or greater)
-   *
-   * @see https://www.rabbitmq.com/docs/quorum-queues#poison-message-handling
-   *
-   * @example
-   * ```typescript
-   * const orderQueue = defineQueue('order-processing', {
-   *   type: 'quorum',
-   *   deliveryLimit: 5, // Allow up to 5 delivery attempts
-   *   deadLetter: {
-   *     exchange: dlx,
-   *     routingKey: 'order.failed',
-   *   },
-   * });
-   * ```
-   */
-  deliveryLimit?: number;
-  /**
-   * Retry configuration for handling failed message processing.
-   *
-   * Determines how the worker handles retries for consumers using this queue:
-   * - `"ttl-backoff"` (default): Uses wait queues with exponential backoff
-   * - `"quorum-native"`: Uses RabbitMQ's native delivery limit feature
-   *
-   * When using `"ttl-backoff"` mode, the core package will automatically create
-   * a wait queue (`{queueName}-wait`) and the necessary bindings.
-   *
-   * @example
-   * ```typescript
-   * // TTL-backoff mode with custom options
-   * const orderQueue = defineQueue('order-processing', {
-   *   type: 'quorum',
-   *   deadLetter: { exchange: dlx },
-   *   retry: {
-   *     mode: 'ttl-backoff',
-   *     maxRetries: 5,
-   *     initialDelayMs: 1000,
-   *     maxDelayMs: 30000,
-   *   },
-   * });
-   *
-   * // Quorum-native mode
-   * const orderQueue = defineQueue('order-processing', {
-   *   type: 'quorum',
-   *   deliveryLimit: 5,
-   *   deadLetter: { exchange: dlx },
-   *   retry: { mode: 'quorum-native' },
-   * });
-   * ```
-   */
-  retry?: TtlBackoffRetryOptions | QuorumNativeRetryOptions;
 };
 /**
  * Options for creating a classic queue.
  *
  * Classic queues support all traditional RabbitMQ features including:
- * - `exclusive: true` - For connection-scoped queues
+ * - `exclusive` - For connection-scoped queues
+ * - `autoDelete` - For auto-deleting queues when consumers disconnect
  * - `maxPriority` - For priority queues
  * - `durable: false` - For non-durable queues
  *
@@ -291,7 +311,6 @@ type QuorumQueueOptions = BaseQueueOptions & {
  * ```typescript
  * const priorityQueue = defineQueue('tasks', {
  *   type: 'classic',
- *   durable: true,
  *   maxPriority: 10,
  * });
  * ```
@@ -301,48 +320,42 @@ type ClassicQueueOptions = BaseQueueOptions & {
    * Queue type: classic (for special cases)
    */
   type: "classic";
+  /**
+   * If true, the queue survives broker restarts. Durable queues are persisted to disk.
+   * @default true
+   */
+  durable?: boolean;
   /**
    * If true, the queue can only be used by the declaring connection and is deleted when
    * that connection closes. Exclusive queues are private to the connection.
-   * @default false
    */
   exclusive?: boolean;
+  /**
+   * If true, the queue is deleted when the last consumer unsubscribes.
+   */
+  autoDelete?: boolean;
   /**
    * Maximum priority level for priority queue (1-255, recommended: 1-10).
    * Sets x-max-priority argument.
-   * Only supported with classic queues.
    */
   maxPriority?: number;
-  /**
-   * Retry configuration for handling failed message processing.
-   *
-   * Classic queues only support TTL-backoff retry mode, which uses wait queues
-   * with exponential backoff. For quorum-native retry, use quorum queues instead.
-   *
-   * @example
-   * ```typescript
-   * const orderQueue = defineQueue('order-processing', {
-   *   type: 'classic',
-   *   durable: true,
-   *   deadLetter: { exchange: dlx },
-   *   retry: {
-   *     maxRetries: 5,
-   *     initialDelayMs: 1000,
-   *     maxDelayMs: 30000,
-   *   },
-   * });
-   * ```
-   */
-  retry?: TtlBackoffRetryOptions;
 };
 /**
  * Options for defining a queue. Uses a discriminated union based on the `type` property
  * to enforce quorum queue constraints at compile time.
  *
- * - Quorum queues (default): Do not support `exclusive` or `maxPriority`
- * - Classic queues: Support all options including `exclusive` and `maxPriority`
+ * - Quorum queues (default): Do not support `exclusive`, `autoDelete`, or `maxPriority`
+ * - Classic queues: Support all options including `exclusive`, `autoDelete`, and `maxPriority`
  */
 type DefineQueueOptions = QuorumQueueOptions | ClassicQueueOptions;
+/**
+ * Options for defining a queue with a dead letter exchange.
+ */
+type DefineQueueOptionsWithDeadLetterExchange<TDlx extends ExchangeDefinition = ExchangeDefinition> = DefineQueueOptions & {
+  deadLetter: {
+    exchange: TDlx;
+  };
+};
 /**
  * Base definition of an AMQP exchange.
  *
@@ -356,18 +369,16 @@ type BaseExchangeDefinition<TName extends string = string> = {
   name: TName;
   /**
    * If true, the exchange survives broker restarts. Durable exchanges are persisted to disk.
-   * @default false
+   * @default true
    */
   durable?: boolean;
   /**
    * If true, the exchange is deleted when all queues have finished using it.
-   * @default false
    */
   autoDelete?: boolean;
   /**
    * If true, the exchange cannot be directly published to by clients.
    * It can only receive messages from other exchanges via exchange-to-exchange bindings.
-   * @default false
    */
   internal?: boolean;
   /**
@@ -377,20 +388,24 @@ type BaseExchangeDefinition<TName extends string = string> = {
   arguments?: Record<string, unknown>;
 };
 /**
- * A fanout exchange definition.
+ * A topic exchange definition.
  *
- * Fanout exchanges broadcast all messages to all bound queues, ignoring routing keys.
- * This is the simplest exchange type for pub/sub messaging patterns.
+ * Topic exchanges route messages to queues based on routing key patterns with wildcards:
+ * - `*` (star) matches exactly one word
+ * - `#` (hash) matches zero or more words
+ *
+ * Words are separated by dots (e.g., `order.created.high-value`).
  *
  * @example
  * ```typescript
- * const logsExchange: FanoutExchangeDefinition = defineExchange('logs', 'fanout', {
- *   durable: true
+ * const ordersExchange: TopicExchangeDefinition = defineExchange('orders', {
+ *   type: 'topic', // This is the default type, so it can be omitted
  * });
+ * // Can be bound with patterns like 'order.*' or 'order.#'
  * ```
  */
-type FanoutExchangeDefinition<TName extends string = string> = BaseExchangeDefinition<TName> & {
-  type: "fanout";
+type TopicExchangeDefinition<TName extends string = string> = BaseExchangeDefinition<TName> & {
+  type: "topic";
 };
 /**
  * A direct exchange definition.
@@ -400,8 +415,8 @@ type FanoutExchangeDefinition<TName extends string = string> = BaseExchangeDefin
  *
  * @example
  * ```typescript
- * const tasksExchange: DirectExchangeDefinition = defineExchange('tasks', 'direct', {
- *   durable: true
+ * const tasksExchange: DirectExchangeDefinition = defineExchange('tasks', {
+ *   type: 'direct',
  * });
  * ```
  */
@@ -409,31 +424,43 @@ type DirectExchangeDefinition<TName extends string = string> = BaseExchangeDefin
   type: "direct";
 };
 /**
- * A topic exchange definition.
+ * A fanout exchange definition.
  *
- * Topic exchanges route messages to queues based on routing key patterns with wildcards:
- * - `*` (star) matches exactly one word
- * - `#` (hash) matches zero or more words
+ * Fanout exchanges broadcast all messages to all bound queues, ignoring routing keys.
+ * This is the simplest exchange type for pub/sub messaging patterns.
  *
- * Words are separated by dots (e.g., `order.created.high-value`).
+ * @example
+ * ```typescript
+ * const logsExchange: FanoutExchangeDefinition = defineExchange('logs', {
+ *   type: 'fanout',
+ * });
+ * ```
+ */
+type FanoutExchangeDefinition<TName extends string = string> = BaseExchangeDefinition<TName> & {
+  type: "fanout";
+};
+/**
+ * A headers exchange definition.
+ *
+ * Headers exchanges route messages based on header values rather than routing keys.
+ * This is useful for more complex routing scenarios where metadata is important.
  *
  * @example
  * ```typescript
- * const ordersExchange: TopicExchangeDefinition = defineExchange('orders', 'topic', {
- *   durable: true
+ * const routesExchange: HeadersExchangeDefinition = defineExchange('routes', {
+ *   type: 'headers',
  * });
- * // Can be bound with patterns like 'order.*' or 'order.#'
  * ```
  */
-type TopicExchangeDefinition<TName extends string = string> = BaseExchangeDefinition<TName> & {
-  type: "topic";
+type HeadersExchangeDefinition<TName extends string = string> = BaseExchangeDefinition<TName> & {
+  type: "headers";
 };
 /**
  * Union type of all exchange definitions.
  *
- * Represents any type of AMQP exchange: fanout, direct, or topic.
+ * Represents any type of AMQP exchange: topic, direct, fanout, headers.
  */
-type ExchangeDefinition<TName extends string = string> = FanoutExchangeDefinition<TName> | DirectExchangeDefinition<TName> | TopicExchangeDefinition<TName>;
+type ExchangeDefinition<TName extends string = string> = TopicExchangeDefinition<TName> | DirectExchangeDefinition<TName> | FanoutExchangeDefinition<TName> | HeadersExchangeDefinition<TName>;
 /**
  * Configuration for dead letter exchange (DLX) on a queue.
  *
@@ -461,17 +488,6 @@ type BaseQueueDefinition<TName extends string = string> = {
    * The name of the queue. Must be unique within the RabbitMQ virtual host.
    */
   name: TName;
-  /**
-   * If true, the queue survives broker restarts. Durable queues are persisted to disk.
-   * Note: Quorum queues are always durable regardless of this setting.
-   * @default false (but forced to true for quorum queues during setup)
-   */
-  durable?: boolean;
-  /**
-   * If true, the queue is deleted when the last consumer unsubscribes.
-   * @default false
-   */
-  autoDelete?: boolean;
   /**
    * Dead letter configuration for handling failed or rejected messages.
    *
@@ -479,6 +495,11 @@ type BaseQueueDefinition<TName extends string = string> = {
    * will be automatically forwarded to the specified dead letter exchange.
    */
   deadLetter?: DeadLetterConfig;
+  /**
+   * Retry configuration for handling failed message processing.
+   * When the queue is created, defaults are applied.
+   */
+  retry: ResolvedRetryOptions;
   /**
    * Additional AMQP arguments for advanced configuration.
    *
@@ -494,52 +515,37 @@ type BaseQueueDefinition<TName extends string = string> = {
  * Definition of a quorum queue.
  *
  * Quorum queues provide better durability and high-availability using the Raft consensus algorithm.
- * They support native retry handling via `deliveryLimit` and both TTL-backoff and quorum-native retry modes.
  */
 type QuorumQueueDefinition<TName extends string = string> = BaseQueueDefinition<TName> & {
   /**
    * Queue type discriminator: quorum queue.
    */
   type: "quorum";
+  /**
+   * Quorum queues only support durable queues.
+   */
+  durable: true;
   /**
    * Quorum queues do not support exclusive mode.
    * Use type: 'classic' if you need exclusive queues.
    */
   exclusive?: never;
+  /**
+   * Quorum queues do not support auto-delete mode.
+   * Use type: 'classic' if you need auto-deleting queues.
+   */
+  autoDelete?: never;
   /**
    * Quorum queues do not support priority queues.
    * Use type: 'classic' if you need priority queues.
    */
   maxPriority?: never;
-  /**
-   * Maximum number of delivery attempts before the message is dead-lettered.
-   *
-   * This is a quorum queue-specific feature. When a message is rejected (nacked)
-   * and requeued, RabbitMQ increments the `x-delivery-count` header. When this
-   * count reaches the delivery limit, the message is automatically dead-lettered
-   * (if DLX is configured) or dropped.
-   *
-   * @minimum 1 - Must be a positive integer (1 or greater)
-   *
-   * @see https://www.rabbitmq.com/docs/quorum-queues#poison-message-handling
-   */
-  deliveryLimit?: number;
-  /**
-   * Retry configuration for handling failed message processing.
-   *
-   * Quorum queues support both:
-   * - `ttl-backoff`: Uses wait queues with exponential backoff (default)
-   * - `quorum-native`: Uses RabbitMQ's native delivery limit feature
-   *
-   * When the queue is created, defaults are applied for TTL-backoff options.
-   */
-  retry: ResolvedRetryOptions;
 };
 /**
  * Definition of a classic queue.
  *
  * Classic queues are the traditional RabbitMQ queue type. Use them when you need
- * specific features not supported by quorum queues (e.g., exclusive queues, priority queues).
+ * specific features not supported by quorum queues (e.g., exclusive queues, auto-deleting queues, priority queues).
  */
 type ClassicQueueDefinition<TName extends string = string> = BaseQueueDefinition<TName> & {
   /**
@@ -547,23 +553,23 @@ type ClassicQueueDefinition<TName extends string = string> = BaseQueueDefinition
    */
   type: "classic";
   /**
-   * Classic queues do not support delivery limits.
-   * Use type: 'quorum' if you need native retry with delivery limits.
+   * If true, the queue survives broker restarts. Durable queues are persisted to disk.
    */
-  deliveryLimit?: never;
+  durable: boolean;
   /**
    * If true, the queue can only be used by the declaring connection and is deleted when
    * that connection closes. Exclusive queues are private to the connection.
-   * @default false
    */
   exclusive?: boolean;
   /**
-   * Retry configuration for handling failed message processing.
-   *
-   * Classic queues only support TTL-backoff retry mode (default).
-   * When the queue is created, defaults are applied.
+   * If true, the queue is deleted when the last consumer unsubscribes.
+   */
+  autoDelete?: boolean;
+  /**
+   * Maximum priority level for priority queue (1-255, recommended: 1-10).
+   * Sets x-max-priority argument.
    */
-  retry: ResolvedTtlBackoffRetryOptions;
+  maxPriority?: number;
 };
 /**
  * Definition of an AMQP queue.
@@ -578,26 +584,24 @@ type QueueDefinition<TName extends string = string> = QuorumQueueDefinition<TNam
 /**
  * A queue with automatically generated TTL-backoff retry infrastructure.
  *
- * This type is returned by `defineQueue` when TTL-backoff retry is configured
- * with a dead letter exchange. When passed to `defineContract`, the wait queue
- * and bindings are automatically added to the contract.
+ * This type is returned by `defineQueue` when TTL-backoff retry is configured.
+ * When passed to `defineContract`, the wait queue, exchanges, and bindings are
+ * automatically added to the contract.
  *
  * @example
  * ```typescript
- * const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
- * const exchange = defineExchange('orders', 'topic', { durable: true });
+ * const exchange = defineExchange('orders');
  * const queue = defineQueue('order-processing', {
- *   deadLetter: { exchange: dlx },
  *   retry: { mode: 'ttl-backoff', maxRetries: 5 },
  * });
  * // queue is QueueWithTtlBackoffInfrastructure
  * const message = defineMessage(z.object({ orderId: z.string() }));
  * const orderCreated = defineEventPublisher(exchange, message, { routingKey: 'order.created' });
  *
- * // Wait queue, bindings, and DLX exchange are automatically extracted
+ * // Wait queue, exchanges, and bindings are automatically extracted
  * const contract = defineContract({
  *   publishers: { orderCreated },
- *   consumers: { processOrder: defineEventConsumer(orderCreated, extractQueue(queue)) },
+ *   consumers: { processOrder: defineEventConsumer(orderCreated, queue) },
  * });
  * ```
  */
@@ -611,23 +615,26 @@ type QueueWithTtlBackoffInfrastructure<TName extends string = string> = {
    * The main queue definition.
    */
   queue: QueueDefinition<TName>;
-  /**
-   * Dead letter configuration from the main queue.
-   * Always present since TTL-backoff infrastructure requires a dead letter exchange.
-   */
-  deadLetter: DeadLetterConfig;
   /**
    * The wait queue for holding messages during backoff delay.
    */
   waitQueue: QueueDefinition;
+  /**
+   * Wait exchange used to route failed messages to the wait queue.
+   */
+  waitExchange: HeadersExchangeDefinition;
+  /**
+   * Retry exchange used to route messages to retry back to the main queue.
+   */
+  retryExchange: HeadersExchangeDefinition;
   /**
    * Binding that routes failed messages to the wait queue.
    */
   waitQueueBinding: QueueBindingDefinition;
   /**
-   * Binding that routes retried messages back to the main queue.
+   * Binding that routes messages to retry back to the main queue.
    */
-  mainQueueRetryBinding: QueueBindingDefinition;
+  retryQueueBinding: QueueBindingDefinition;
 };
 /**
  * A queue entry that can be passed to `defineContract`.
@@ -635,6 +642,14 @@ type QueueWithTtlBackoffInfrastructure<TName extends string = string> = {
  * Can be either a plain queue definition or a queue with TTL-backoff infrastructure.
  */
 type QueueEntry<TName extends string = string> = QueueDefinition<TName> | QueueWithTtlBackoffInfrastructure<TName>;
+/**
+ * A queue entry with a dead letter exchange.
+ */
+type QueueEntryWithDeadLetterExchange<TName extends string = string, TDlx extends ExchangeDefinition = ExchangeDefinition> = QueueEntry<TName> & {
+  deadLetter: {
+    exchange: TDlx;
+  };
+};
 /**
  * Definition of a message with typed payload and optional headers.
  *
@@ -668,7 +683,7 @@ type MessageDefinition<TPayload extends AnySchema = AnySchema, THeaders extends
  *
  * Defines how messages from an exchange should be routed to a queue.
  * For direct and topic exchanges, a routing key is required.
- * For fanout exchanges, no routing key is needed as all messages are broadcast.
+ * For fanout and headers exchanges, no routing key is needed.
  */
 type QueueBindingDefinition = {
   /** Discriminator indicating this is a queue-to-exchange binding */type: "queue"; /** The queue that will receive messages */
@@ -687,7 +702,7 @@ type QueueBindingDefinition = {
    */
   routingKey: string;
 } | {
-  /** Fanout exchange (no routing key needed) */exchange: FanoutExchangeDefinition; /** Fanout exchanges don't use routing keys */
+  /** Fanout or headers exchange (no routing key needed) */exchange: FanoutExchangeDefinition | HeadersExchangeDefinition; /** Fanout and headers exchanges don't use routing keys */
   routingKey?: never;
 });
 /**
@@ -722,7 +737,7 @@ type ExchangeBindingDefinition = {
    */
   routingKey: string;
 } | {
-  /** Fanout source exchange (no routing key needed) */source: FanoutExchangeDefinition; /** Fanout exchanges don't use routing keys */
+  /** Fanout or headers source exchange (no routing key needed) */source: FanoutExchangeDefinition | HeadersExchangeDefinition; /** Fanout and headers exchanges don't use routing keys */
   routingKey?: never;
 });
 /**
@@ -763,7 +778,7 @@ type PublisherDefinition<TMessage extends MessageDefinition = MessageDefinition>
    */
   routingKey: string;
 } | {
-  /** Fanout exchange (no routing key needed) */exchange: FanoutExchangeDefinition; /** Fanout exchanges don't use routing keys - all bound queues receive the message */
+  /** Fanout or headers exchange (no routing key needed) */exchange: FanoutExchangeDefinition | HeadersExchangeDefinition; /** Fanout and headers exchanges don't use routing keys */
   routingKey?: never;
 });
 /**
@@ -785,7 +800,7 @@ type PublisherDefinition<TMessage extends MessageDefinition = MessageDefinition>
  * ```
  */
 type ConsumerDefinition<TMessage extends MessageDefinition = MessageDefinition> = {
-  /** The queue to consume messages from */queue: QueueDefinition; /** The message definition including the payload schema */
+  /** The queue to consume messages from */queue: QueueEntry; /** The message definition including the payload schema */
   message: TMessage;
 };
 /**
@@ -816,8 +831,7 @@ type CommandConsumerConfigBase = {
   consumer: ConsumerDefinition;
   binding: QueueBindingDefinition;
   exchange: ExchangeDefinition;
-  queue: QueueDefinition;
-  deadLetterExchange: ExchangeDefinition | undefined;
+  queue: QueueEntry;
   message: MessageDefinition;
   routingKey: string | undefined;
 };
@@ -834,8 +848,7 @@ type EventConsumerResultBase = {
   consumer: ConsumerDefinition;
   binding: QueueBindingDefinition;
   exchange: ExchangeDefinition;
-  queue: QueueDefinition;
-  deadLetterExchange: ExchangeDefinition | undefined;
+  queue: QueueEntry;
   exchangeBinding: ExchangeBindingDefinition | undefined;
   bridgeExchange: ExchangeDefinition | undefined;
 };
@@ -854,6 +867,26 @@ type BridgedPublisherConfigBase = {
   bridgeExchange: ExchangeDefinition;
   targetExchange: ExchangeDefinition;
 };
+/**
+ * Definition of an RPC operation: a request/response pair flowing over a
+ * request queue with replies routed back via direct reply-to.
+ *
+ * An RPC is bidirectional on both ends — the server consumes requests and
+ * publishes responses; the client publishes requests and consumes responses —
+ * so it has its own slot in the contract (`rpcs`) rather than being shoehorned
+ * into `consumers` or `publishers`.
+ *
+ * @template TRequestMessage - The request message definition
+ * @template TResponseMessage - The response message definition
+ * @template TQueue - The request queue entry
+ *
+ * @see defineRpc for creating RPC definitions
+ */
+type RpcDefinition<TRequestMessage extends MessageDefinition = MessageDefinition, TResponseMessage extends MessageDefinition = MessageDefinition, TQueue extends QueueEntry = QueueEntry> = {
+  /** The queue that receives RPC requests. Replies are routed back via direct reply-to. */queue: TQueue; /** Schema for the request payload (validated on both publish and consume). */
+  request: TRequestMessage; /** Schema for the response payload (validated on both worker reply and client receive). */
+  response: TResponseMessage;
+};
 /**
  * Complete AMQP contract definition (output type).
  *
@@ -898,7 +931,7 @@ type ContractDefinition = {
    * Each key becomes available as a named resource in the contract.
    *
    * When a queue has TTL-backoff retry configured, pass the `QueueWithTtlBackoffInfrastructure`
-   * object returned by `defineQueue`. The wait queue and bindings will be automatically added.
+   * object returned by `defineQueue`. The wait queue, exchanges, and bindings will be automatically added.
    */
   queues?: Record<string, QueueEntry>;
   /**
@@ -918,6 +951,16 @@ type ContractDefinition = {
    * The handler will be fully typed based on the message schema.
    */
   consumers?: Record<string, ConsumerDefinition>;
+  /**
+   * Named RPC definitions. Each key gets:
+   * - A handler in the TypedAmqpWorker that returns the typed response.
+   * - A `client.call(name, request, options)` method on the TypedAmqpClient.
+   *
+   * RPC entries do not appear in `publishers` or `consumers` because each
+   * end of an RPC plays both roles (publisher of one direction, consumer of
+   * the other).
+   */
+  rpcs?: Record<string, RpcDefinition>;
 };
 /**
  * Publisher entry that can be passed to defineContract's publishers section.
@@ -925,6 +968,7 @@ type ContractDefinition = {
  * Can be either:
  * - A plain PublisherDefinition from definePublisher
  * - An EventPublisherConfig from defineEventPublisher (auto-extracted to publisher)
+ * - An BridgedPublisherConfig from defineCommandPublisher (auto-extracted to publisher)
  */
 type PublisherEntry = PublisherDefinition | EventPublisherConfigBase | BridgedPublisherConfigBase;
 /**
@@ -978,6 +1022,12 @@ type ContractDefinitionInput = {
    * - CommandConsumerConfig from defineCommandConsumer (binding auto-extracted)
    */
   consumers?: Record<string, ConsumerEntry>;
+  /**
+   * Named RPC definitions from `defineRpc`. Each entry contributes its queue
+   * (and DLX if any) to the contract topology and exposes a typed
+   * `client.call(name, ...)` / worker handler pair.
+   */
+  rpcs?: Record<string, RpcDefinition>;
 };
 /**
  * Extract the exchange from a publisher entry.
@@ -1005,7 +1055,7 @@ type ExtractDlxFromEntry<T extends QueueEntry> = T extends {
   deadLetter: {
     exchange: infer E extends ExchangeDefinition;
   };
-} ? E : undefined : undefined;
+} ? E : never : never;
 /**
  * Extract the queue from a consumer entry.
  * @internal
@@ -1040,11 +1090,7 @@ type ExtractExchangesFromConsumers<TConsumers extends Record<string, ConsumerEnt
  * Extract the dead letter exchange from a consumer entry.
  * @internal
  */
-type ExtractDeadLetterExchange<T extends ConsumerEntry> = T extends EventConsumerResultBase | CommandConsumerConfigBase ? T["deadLetterExchange"] extends ExchangeDefinition ? T["deadLetterExchange"] : never : T extends ConsumerDefinition ? T["queue"] extends {
-  deadLetter: {
-    exchange: infer E extends ExchangeDefinition;
-  };
-} ? E : never : never;
+type ExtractDeadLetterExchange<T extends ConsumerEntry> = ExtractDlxFromEntry<T["queue"]>;
 /**
  * Extract dead letter exchanges from all consumers in a contract.
  * @internal
@@ -1054,7 +1100,7 @@ type ExtractDeadLetterExchangesFromConsumers<TConsumers extends Record<string, C
  * Extract queues from all consumers in a contract.
  * @internal
  */
-type ExtractQueuesFromConsumers<TConsumers extends Record<string, ConsumerEntry>> = { [K in keyof TConsumers as ExtractConsumerQueue<TConsumers[K]>["name"]]: ExtractConsumerQueue<TConsumers[K]> };
+type ExtractQueuesFromConsumers<TConsumers extends Record<string, ConsumerEntry>> = { [K in keyof TConsumers as ExtractQueueFromEntry<ExtractConsumerQueue<TConsumers[K]>>["name"]]: ExtractConsumerQueue<TConsumers[K]> };
 /**
  * Extract bindings from all consumers in a contract.
  * @internal
@@ -1074,12 +1120,12 @@ type ExtractConsumerDefinitions<TConsumers extends Record<string, ConsumerEntry>
  * Extract the publisher definition from a publisher entry.
  * @internal
  */
-type ExtractPublisherDefinition<T extends PublisherEntry> = T extends BridgedPublisherConfigBase ? T["publisher"] : T extends EventPublisherConfigBase ? PublisherDefinition<T["message"]> & (T["exchange"] extends FanoutExchangeDefinition ? {
+type ExtractPublisherDefinition<T extends PublisherEntry> = T extends BridgedPublisherConfigBase ? T["publisher"] : T extends EventPublisherConfigBase ? PublisherDefinition<T["message"]> & (T["exchange"] extends DirectExchangeDefinition | TopicExchangeDefinition ? {
   exchange: T["exchange"];
-  routingKey?: never;
+  routingKey: T["routingKey"] & string;
 } : {
   exchange: T["exchange"];
-  routingKey: T["routingKey"] & string;
+  routingKey?: never;
 }) : T extends PublisherDefinition ? T : never;
 /**
  * Extract publisher definitions from all publishers in a contract.
@@ -1136,6 +1182,16 @@ type ExtractPublisherExchangeBinding<T extends PublisherEntry> = T extends Bridg
  * @internal
  */
 type ExtractExchangeBindingsFromPublishers<TPublishers extends Record<string, PublisherEntry>> = { [K in keyof TPublishers as HasPublisherExchangeBinding<TPublishers[K]> extends true ? `${K & string}ExchangeBinding` : never]: ExtractPublisherExchangeBinding<TPublishers[K]> };
+/**
+ * Extract queues from all RPC entries in a contract.
+ * @internal
+ */
+type ExtractQueuesFromRpcs<TRpcs extends Record<string, RpcDefinition>> = { [K in keyof TRpcs as ExtractQueueFromEntry<TRpcs[K]["queue"]>["name"]]: TRpcs[K]["queue"] };
+/**
+ * Extract dead letter exchanges from all RPC entries in a contract.
+ * @internal
+ */
+type ExtractDeadLetterExchangesFromRpcs<TRpcs extends Record<string, RpcDefinition>> = { [K in keyof TRpcs as ExtractDlxFromEntry<TRpcs[K]["queue"]> extends never ? never : ExtractDlxFromEntry<TRpcs[K]["queue"]>["name"]]: ExtractDlxFromEntry<TRpcs[K]["queue"]> };
 /**
  * Contract output type with all resources extracted and properly typed.
  *
@@ -1147,11 +1203,12 @@ type ExtractExchangeBindingsFromPublishers<TPublishers extends Record<string, Pu
  * - consumers: Normalized consumer definitions
  */
 type ContractOutput<TContract extends ContractDefinitionInput> = {
-  exchanges: (TContract["publishers"] extends Record<string, PublisherEntry> ? ExtractExchangesFromPublishers<TContract["publishers"]> : {}) & (TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractExchangesFromConsumers<TContract["consumers"]> : {}) & (TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractDeadLetterExchangesFromConsumers<TContract["consumers"]> : {}) & (TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractBridgeExchangesFromConsumers<TContract["consumers"]> : {}) & (TContract["publishers"] extends Record<string, PublisherEntry> ? ExtractTargetExchangesFromPublishers<TContract["publishers"]> : {});
-  queues: TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractQueuesFromConsumers<TContract["consumers"]> : {};
+  exchanges: (TContract["publishers"] extends Record<string, PublisherEntry> ? ExtractExchangesFromPublishers<TContract["publishers"]> : {}) & (TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractExchangesFromConsumers<TContract["consumers"]> : {}) & (TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractDeadLetterExchangesFromConsumers<TContract["consumers"]> : {}) & (TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractBridgeExchangesFromConsumers<TContract["consumers"]> : {}) & (TContract["publishers"] extends Record<string, PublisherEntry> ? ExtractTargetExchangesFromPublishers<TContract["publishers"]> : {}) & (TContract["rpcs"] extends Record<string, RpcDefinition> ? ExtractDeadLetterExchangesFromRpcs<TContract["rpcs"]> : {});
+  queues: (TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractQueuesFromConsumers<TContract["consumers"]> : {}) & (TContract["rpcs"] extends Record<string, RpcDefinition> ? ExtractQueuesFromRpcs<TContract["rpcs"]> : {});
   bindings: (TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractBindingsFromConsumers<TContract["consumers"]> : {}) & (TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractExchangeBindingsFromConsumers<TContract["consumers"]> : {}) & (TContract["publishers"] extends Record<string, PublisherEntry> ? ExtractExchangeBindingsFromPublishers<TContract["publishers"]> : {});
   publishers: TContract["publishers"] extends Record<string, PublisherEntry> ? ExtractPublisherDefinitions<TContract["publishers"]> : {};
   consumers: TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractConsumerDefinitions<TContract["consumers"]> : {};
+  rpcs: TContract["rpcs"] extends Record<string, RpcDefinition> ? TContract["rpcs"] : {};
 };
 /**
  * Extract publisher names from a contract.
@@ -1185,31 +1242,45 @@ type InferPublisherNames<TContract extends ContractDefinition> = TContract["publ
  * ```
  */
 type InferConsumerNames<TContract extends ContractDefinition> = TContract["consumers"] extends Record<string, unknown> ? keyof TContract["consumers"] : never;
+/**
+ * Extract RPC names from a contract.
+ *
+ * Each name in this union has a typed worker handler and a `client.call(name, ...)`
+ * method. RPC names are disjoint from `InferConsumerNames` and `InferPublisherNames`.
+ *
+ * @template TContract - The contract definition
+ * @returns Union of RPC names, or never if no RPCs defined
+ */
+type InferRpcNames<TContract extends ContractDefinition> = TContract["rpcs"] extends Record<string, RpcDefinition> ? keyof TContract["rpcs"] : never;
 //#endregion
 //#region src/builder/exchange.d.ts
 /**
- * Define a fanout exchange.
+ * Define a topic exchange.
  *
- * A fanout exchange routes messages to all bound queues without considering routing keys.
- * This exchange type is ideal for broadcasting messages to multiple consumers.
+ * A topic exchange routes messages to queues based on routing key patterns.
+ * Routing keys can use wildcards: `*` matches one word, `#` matches zero or more words.
+ * This exchange type is ideal for flexible message routing based on hierarchical topics.
  *
  * @param name - The name of the exchange
- * @param type - Must be "fanout"
  * @param options - Optional exchange configuration
- * @param options.durable - If true, the exchange survives broker restarts (default: false)
- * @param options.autoDelete - If true, the exchange is deleted when no queues are bound (default: false)
- * @param options.internal - If true, the exchange cannot be directly published to (default: false)
+ * @param options.type - Exchange type (must be "topic", or omitted for default topic exchange)
+ * @param options.durable - If true, the exchange survives broker restarts (default: true)
+ * @param options.autoDelete - If true, the exchange is deleted when no queues are bound
+ * @param options.internal - If true, the exchange cannot be directly published to
  * @param options.arguments - Additional AMQP arguments for the exchange
- * @returns A fanout exchange definition
+ * @returns A topic exchange definition
  *
  * @example
  * ```typescript
- * const logsExchange = defineExchange('logs', 'fanout', {
- *   durable: true
- * });
+ * const ordersExchange = defineExchange('orders', { type: 'topic' });
+ *
+ * // Or omit type for default topic exchange
+ * const ordersExchange = defineExchange('orders');
  * ```
  */
-declare function defineExchange<TName extends string>(name: TName, type: "fanout", options?: Omit<BaseExchangeDefinition, "name" | "type">): FanoutExchangeDefinition<TName>;
+declare function defineExchange<TName extends string>(name: TName, options?: {
+  type?: "topic";
+} & Omit<BaseExchangeDefinition, "name" | "type">): TopicExchangeDefinition<TName>;
 /**
  * Define a direct exchange.
  *
@@ -1217,46 +1288,68 @@ declare function defineExchange<TName extends string>(name: TName, type: "fanout
  * This exchange type is ideal for point-to-point messaging.
  *
  * @param name - The name of the exchange
- * @param type - Must be "direct"
- * @param options - Optional exchange configuration
- * @param options.durable - If true, the exchange survives broker restarts (default: false)
- * @param options.autoDelete - If true, the exchange is deleted when no queues are bound (default: false)
- * @param options.internal - If true, the exchange cannot be directly published to (default: false)
+ * @param options - Exchange configuration
+ * @param options.type - Exchange type (must be "direct")
+ * @param options.durable - If true, the exchange survives broker restarts (default: true)
+ * @param options.autoDelete - If true, the exchange is deleted when no queues are bound
+ * @param options.internal - If true, the exchange cannot be directly published to
  * @param options.arguments - Additional AMQP arguments for the exchange
  * @returns A direct exchange definition
  *
  * @example
  * ```typescript
- * const tasksExchange = defineExchange('tasks', 'direct', {
- *   durable: true
- * });
+ * const tasksExchange = defineExchange('tasks', { type: 'direct' });
  * ```
  */
-declare function defineExchange<TName extends string>(name: TName, type: "direct", options?: Omit<BaseExchangeDefinition, "name" | "type">): DirectExchangeDefinition<TName>;
+declare function defineExchange<TName extends string>(name: TName, options: {
+  type: "direct";
+} & Omit<BaseExchangeDefinition, "name" | "type">): DirectExchangeDefinition<TName>;
 /**
- * Define a topic exchange.
+ * Define a fanout exchange.
  *
- * A topic exchange routes messages to queues based on routing key patterns.
- * Routing keys can use wildcards: `*` matches one word, `#` matches zero or more words.
- * This exchange type is ideal for flexible message routing based on hierarchical topics.
+ * A fanout exchange routes messages to all bound queues without considering routing keys.
+ * This exchange type is ideal for broadcasting messages to multiple consumers.
  *
  * @param name - The name of the exchange
- * @param type - Must be "topic"
- * @param options - Optional exchange configuration
- * @param options.durable - If true, the exchange survives broker restarts (default: false)
- * @param options.autoDelete - If true, the exchange is deleted when no queues are bound (default: false)
- * @param options.internal - If true, the exchange cannot be directly published to (default: false)
+ * @param options - Exchange configuration
+ * @param options.type - Exchange type (must be "fanout")
+ * @param options.durable - If true, the exchange survives broker restarts (default: true)
+ * @param options.autoDelete - If true, the exchange is deleted when no queues are bound
+ * @param options.internal - If true, the exchange cannot be directly published to
  * @param options.arguments - Additional AMQP arguments for the exchange
- * @returns A topic exchange definition
+ * @returns A fanout exchange definition
  *
  * @example
  * ```typescript
- * const ordersExchange = defineExchange('orders', 'topic', {
- *   durable: true
- * });
+ * const logsExchange = defineExchange('logs', { type: 'fanout' });
  * ```
  */
-declare function defineExchange<TName extends string>(name: TName, type: "topic", options?: Omit<BaseExchangeDefinition, "name" | "type">): TopicExchangeDefinition<TName>;
+declare function defineExchange<TName extends string>(name: TName, options: {
+  type: "fanout";
+} & Omit<BaseExchangeDefinition, "name" | "type">): FanoutExchangeDefinition<TName>;
+/**
+ * Define a headers exchange.
+ *
+ * A headers exchange routes messages to all bound queues based on header matching.
+ * This exchange type is ideal for complex routing scenarios.
+ *
+ * @param name - The name of the exchange
+ * @param options - Exchange configuration
+ * @param options.type - Exchange type (must be "headers")
+ * @param options.durable - If true, the exchange survives broker restarts (default: true)
+ * @param options.autoDelete - If true, the exchange is deleted when no queues are bound
+ * @param options.internal - If true, the exchange cannot be directly published to
+ * @param options.arguments - Additional AMQP arguments for the exchange
+ * @returns A headers exchange definition
+ *
+ * @example
+ * ```typescript
+ * const routesExchange = defineExchange('routes', { type: 'headers' });
+ * ```
+ */
+declare function defineExchange<TName extends string>(name: TName, options: {
+  type: "headers";
+} & Omit<BaseExchangeDefinition, "name" | "type">): HeadersExchangeDefinition<TName>;
 //#endregion
 //#region src/builder/message.d.ts
 /**
@@ -1301,89 +1394,6 @@ declare function defineMessage<TPayload extends MessageDefinition["payload"], TH
 }): MessageDefinition<TPayload, THeaders>;
 //#endregion
 //#region src/builder/queue.d.ts
-/**
- * Type guard to check if a queue entry is a QueueWithTtlBackoffInfrastructure.
- *
- * When you configure a queue with TTL-backoff retry and a dead letter exchange,
- * `defineQueue` returns a `QueueWithTtlBackoffInfrastructure` instead of a plain
- * `QueueDefinition`. This type guard helps you distinguish between the two.
- *
- * **When to use:**
- * - When you need to check the type of a queue entry at runtime
- * - When writing generic code that handles both plain queues and infrastructure wrappers
- *
- * **Related functions:**
- * - `extractQueue()` - Use this to get the underlying queue definition from either type
- *
- * @param entry - The queue entry to check
- * @returns True if the entry is a QueueWithTtlBackoffInfrastructure, false otherwise
- *
- * @example
- * ```typescript
- * const queue = defineQueue('orders', {
- *   deadLetter: { exchange: dlx },
- *   retry: { mode: 'ttl-backoff' },
- * });
- *
- * if (isQueueWithTtlBackoffInfrastructure(queue)) {
- *   // queue has .queue, .waitQueue, .waitQueueBinding, .mainQueueRetryBinding
- *   console.log('Wait queue:', queue.waitQueue.name);
- * } else {
- *   // queue is a plain QueueDefinition
- *   console.log('Queue:', queue.name);
- * }
- * ```
- */
-declare function isQueueWithTtlBackoffInfrastructure(entry: QueueEntry): entry is QueueWithTtlBackoffInfrastructure;
-/**
- * Extract the plain QueueDefinition from a QueueEntry.
- *
- * **Why this function exists:**
- * When you configure a queue with TTL-backoff retry and a dead letter exchange,
- * `defineQueue` (or `defineTtlBackoffQueue`) returns a wrapper object that includes
- * the main queue, wait queue, and bindings. This function extracts the underlying
- * queue definition so you can access properties like `name`, `type`, etc.
- *
- * **When to use:**
- * - When you need to access queue properties (name, type, deadLetter, etc.)
- * - When passing a queue to functions that expect a plain QueueDefinition
- * - Works safely on both plain queues and infrastructure wrappers
- *
- * **How it works:**
- * - If the entry is a `QueueWithTtlBackoffInfrastructure`, returns `entry.queue`
- * - Otherwise, returns the entry as-is (it's already a plain QueueDefinition)
- *
- * @param entry - The queue entry (either plain QueueDefinition or QueueWithTtlBackoffInfrastructure)
- * @returns The plain QueueDefinition
- *
- * @example
- * ```typescript
- * import { defineQueue, defineTtlBackoffQueue, extractQueue } from '@amqp-contract/contract';
- *
- * // TTL-backoff queue returns a wrapper
- * const orderQueue = defineTtlBackoffQueue('orders', {
- *   deadLetter: { exchange: dlx },
- *   maxRetries: 3,
- * });
- *
- * // Use extractQueue to access the queue name
- * const queueName = extractQueue(orderQueue).name; // 'orders'
- *
- * // Also works safely on plain queues
- * const plainQueue = defineQueue('simple', { type: 'quorum', retry: { mode: 'quorum-native' } });
- * const plainName = extractQueue(plainQueue).name; // 'simple'
- *
- * // Access other properties
- * const queueDef = extractQueue(orderQueue);
- * console.log(queueDef.name);       // 'orders'
- * console.log(queueDef.type);       // 'quorum'
- * console.log(queueDef.deadLetter); // { exchange: dlx, ... }
- * ```
- *
- * @see isQueueWithTtlBackoffInfrastructure - Type guard to check if extraction is needed
- * @see defineTtlBackoffQueue - Creates queues with TTL-backoff infrastructure
- */
-declare function extractQueue<T extends QueueEntry>(entry: T): ExtractQueueFromEntry<T>;
 /**
  * Define an AMQP queue.
  *
@@ -1397,11 +1407,12 @@ declare function extractQueue<T extends QueueEntry>(entry: T): ExtractQueueFromE
  * @param name - The name of the queue
  * @param options - Optional queue configuration
  * @param options.type - Queue type: 'quorum' (default, recommended) or 'classic'
- * @param options.durable - If true, the queue survives broker restarts. Quorum queues are always durable.
- * @param options.exclusive - If true, the queue can only be used by the declaring connection. Only supported with classic queues.
- * @param options.autoDelete - If true, the queue is deleted when the last consumer unsubscribes (default: false)
- * @param options.deadLetter - Dead letter configuration for handling failed messages
+ * @param options.durable - If true, the queue survives broker restarts. Quorum queues only support durable queues (default: true)
+ * @param options.exclusive - If true, the queue can only be used by the declaring connection and is deleted when that connection closes. Only supported with classic queues.
+ * @param options.autoDelete - If true, the queue is deleted when the last consumer unsubscribes. Only supported with classic queues.
  * @param options.maxPriority - Maximum priority level for priority queue (1-255, recommended: 1-10). Only supported with classic queues.
+ * @param options.deadLetter - Dead letter configuration for handling failed messages
+ * @param options.retry - Retry configuration for handling failed message processing
  * @param options.arguments - Additional AMQP arguments (e.g., x-message-ttl)
  * @returns A queue definition
  *
@@ -1411,7 +1422,7 @@ declare function extractQueue<T extends QueueEntry>(entry: T): ExtractQueueFromE
  * const orderQueue = defineQueue('order-processing');
  *
  * // Explicit quorum queue with dead letter exchange
- * const dlx = defineExchange('orders-dlx', 'topic', { durable: true });
+ * const dlx = defineExchange('orders-dlx');
  * const orderQueueWithDLX = defineQueue('order-processing', {
  *   type: 'quorum',
  *   deadLetter: {
@@ -1433,12 +1444,11 @@ declare function extractQueue<T extends QueueEntry>(entry: T): ExtractQueueFromE
  * // Priority queue (requires classic type)
  * const taskQueue = defineQueue('urgent-tasks', {
  *   type: 'classic',
- *   durable: true,
  *   maxPriority: 10,
  * });
  *
  * // Queue with TTL-backoff retry (returns infrastructure automatically)
- * const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
+ * const dlx = defineExchange('orders-dlx', { type: 'direct' });
  * const orderQueue = defineQueue('order-processing', {
  *   deadLetter: { exchange: dlx },
  *   retry: { mode: 'ttl-backoff', maxRetries: 5 },
@@ -1446,204 +1456,82 @@ declare function extractQueue<T extends QueueEntry>(entry: T): ExtractQueueFromE
  * // orderQueue is QueueWithTtlBackoffInfrastructure, pass directly to defineContract
  * ```
  */
-declare function defineQueue<TName extends string, TDlx extends ExchangeDefinition>(name: TName, options: DefineQueueOptions & {
-  deadLetter: {
-    exchange: TDlx;
-  };
-}): (QueueDefinition<TName> | QueueWithTtlBackoffInfrastructure<TName>) & {
-  deadLetter: {
-    exchange: TDlx;
-  };
-};
-declare function defineQueue<TName extends string>(name: TName, options?: DefineQueueOptions): QueueDefinition<TName> | QueueWithTtlBackoffInfrastructure<TName>;
-/**
- * Options for creating a quorum queue with quorum-native retry.
- *
- * This simplified helper enforces the required configuration for quorum-native retry:
- * - Dead letter exchange is required (for failed messages)
- * - Delivery limit is required (for retry count)
- */
-type DefineQuorumQueueOptions = {
-  /**
-   * Dead letter configuration - required for retry support.
-   * Failed messages will be sent to this exchange.
-   */
-  deadLetter: DeadLetterConfig;
-  /**
-   * Maximum number of delivery attempts before dead-lettering.
-   * @minimum 1
-   */
-  deliveryLimit: number;
-  /**
-   * If true, the queue is deleted when the last consumer unsubscribes.
-   * @default false
-   */
-  autoDelete?: boolean;
-  /**
-   * Additional AMQP arguments for advanced configuration.
-   */
-  arguments?: Record<string, unknown>;
-};
-/**
- * Create a quorum queue with quorum-native retry.
- *
- * This is a simplified helper that enforces best practices:
- * - Uses quorum queues (recommended for most use cases)
- * - Requires dead letter exchange for failed message handling
- * - Uses quorum-native retry mode (simpler than TTL-backoff)
- *
- * **When to use:**
- * - You want simple, immediate retries without exponential backoff
- * - You don't need configurable delays between retries
- * - You want the simplest retry configuration
- *
- * @param name - The queue name
- * @param options - Configuration options
- * @returns A quorum queue definition with quorum-native retry
- *
- * @example
- * ```typescript
- * const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
- *
- * const orderQueue = defineQuorumQueue('order-processing', {
- *   deadLetter: { exchange: dlx },
- *   deliveryLimit: 3, // Retry up to 3 times
- * });
- *
- * // Use in a contract — exchanges, queues, and bindings are auto-extracted
- * const contract = defineContract({
- *   publishers: { ... },
- *   consumers: { processOrder: defineEventConsumer(event, orderQueue) },
- * });
- * ```
- *
- * @see defineQueue - For full queue configuration options
- * @see defineTtlBackoffQueue - For queues with exponential backoff retry
- */
-declare function defineQuorumQueue<TName extends string>(name: TName, options: DefineQuorumQueueOptions): QuorumQueueDefinition<TName>;
-/**
- * Options for creating a queue with TTL-backoff retry.
- *
- * This simplified helper enforces the required configuration for TTL-backoff retry:
- * - Dead letter exchange is required (used for retry routing)
- * - Returns infrastructure that includes wait queue and bindings
- */
-type DefineTtlBackoffQueueOptions = {
-  /**
-   * Dead letter configuration - required for TTL-backoff retry.
-   * Used for routing messages to the wait queue and back.
-   */
-  deadLetter: DeadLetterConfig;
-  /**
-   * Maximum retry attempts before sending to DLQ.
-   * @default 3
-   */
-  maxRetries?: number;
-  /**
-   * Initial delay in ms before first retry.
-   * @default 1000
-   */
-  initialDelayMs?: number;
-  /**
-   * Maximum delay in ms between retries.
-   * @default 30000
-   */
-  maxDelayMs?: number;
-  /**
-   * Exponential backoff multiplier.
-   * @default 2
-   */
-  backoffMultiplier?: number;
-  /**
-   * Add jitter to prevent thundering herd.
-   * @default true
-   */
-  jitter?: boolean;
-  /**
-   * If true, the queue is deleted when the last consumer unsubscribes.
-   * @default false
-   */
-  autoDelete?: boolean;
-  /**
-   * Additional AMQP arguments for advanced configuration.
-   */
-  arguments?: Record<string, unknown>;
-};
+declare function defineQueue<TName extends string, TDlx extends ExchangeDefinition>(name: TName, options: DefineQueueOptionsWithDeadLetterExchange<TDlx>): QueueEntryWithDeadLetterExchange<TName, TDlx>;
+declare function defineQueue<TName extends string>(name: TName, options?: DefineQueueOptions): QueueEntry<TName>;
+//#endregion
+//#region src/builder/queue-utils.d.ts
 /**
- * Create a queue with TTL-backoff retry (exponential backoff).
+ * Extract the plain QueueDefinition from a QueueEntry.
  *
- * This is a simplified helper that enforces best practices:
- * - Uses quorum queues (recommended for most use cases)
- * - Requires dead letter exchange for retry routing
- * - Uses TTL-backoff retry mode with configurable delays
- * - Automatically generates wait queue and bindings
+ * **Why this function exists:**
+ * When you configure a queue with TTL-backoff retry,
+ * `defineQueue` returns a wrapper object that includes
+ * the main queue, wait queue, headers exchanges, and bindings. This function extracts the underlying
+ * queue definition so you can access properties like `name`, `type`, etc.
  *
  * **When to use:**
- * - You need exponential backoff between retries
- * - You want configurable delays (initial delay, max delay, jitter)
- * - You're processing messages that may need time before retry
+ * - When you need to access queue properties (name, type, etc.)
+ * - When passing a queue to functions that expect a plain QueueDefinition
+ * - Works safely on both plain queues and infrastructure wrappers
  *
- * **Returns:** A `QueueWithTtlBackoffInfrastructure` object that includes the
- * main queue, wait queue, and bindings. Pass this directly to `defineContract`
- * and it will be expanded automatically.
+ * **How it works:**
+ * - If the entry is a `QueueWithTtlBackoffInfrastructure`, returns `entry.queue`
+ * - Otherwise, returns the entry as-is (it's already a plain QueueDefinition)
  *
- * @param name - The queue name
- * @param options - Configuration options
- * @returns A queue with TTL-backoff infrastructure
+ * @param entry - The queue entry (either plain QueueDefinition or QueueWithTtlBackoffInfrastructure)
+ * @returns The plain QueueDefinition
  *
  * @example
  * ```typescript
- * const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
+ * import { defineQueue, extractQueue } from '@amqp-contract/contract';
  *
- * const orderQueue = defineTtlBackoffQueue('order-processing', {
- *   deadLetter: { exchange: dlx },
- *   maxRetries: 5,
- *   initialDelayMs: 1000,  // Start with 1s delay
- *   maxDelayMs: 30000,     // Cap at 30s
+ * // TTL-backoff queue returns a wrapper
+ * const orderQueue = defineQueue('orders', {
+ *   retry: { mode: 'ttl-backoff', maxRetries: 3 },
  * });
  *
- * // Use in a contract — wait queue, bindings, and DLX are auto-extracted
- * const contract = defineContract({
- *   publishers: { ... },
- *   consumers: { processOrder: defineEventConsumer(event, extractQueue(orderQueue)) },
- * });
+ * // Use extractQueue to access the queue name
+ * const queueName = extractQueue(orderQueue).name; // 'orders'
+ *
+ * // Also works safely on plain queues
+ * const plainQueue = defineQueue('simple', { type: 'quorum', retry: { mode: 'immediate-requeue' } });
+ * const plainName = extractQueue(plainQueue).name; // 'simple'
  *
- * // To access the underlying queue definition (e.g., for the queue name):
- * import { extractQueue } from '@amqp-contract/contract';
- * const queueName = extractQueue(orderQueue).name;
+ * // Access other properties
+ * const queueDef = extractQueue(orderQueue);
+ * console.log(queueDef.name);       // 'orders'
+ * console.log(queueDef.type);       // 'quorum'
  * ```
  *
- * @see defineQueue - For full queue configuration options
- * @see defineQuorumQueue - For queues with quorum-native retry (simpler, immediate retries)
- * @see extractQueue - To access the underlying queue definition
+ * @see isQueueWithTtlBackoffInfrastructure - Type guard to check if extraction is needed
  */
-declare function defineTtlBackoffQueue<TName extends string>(name: TName, options: DefineTtlBackoffQueueOptions): QueueWithTtlBackoffInfrastructure<TName>;
+declare function extractQueue<T extends QueueEntry>(entry: T): ExtractQueueFromEntry<T>;
 //#endregion
 //#region src/builder/binding.d.ts
 /**
- * Define a binding between a queue and a fanout exchange.
+ * Define a binding between a queue and a fanout or headers exchange.
  *
- * Binds a queue to a fanout exchange to receive all messages published to the exchange.
- * Fanout exchanges ignore routing keys, so this overload doesn't require one.
+ * Binds a queue to a fanout or headers exchange (no routing key needed).
+ * Fanout and headers exchanges ignore routing keys, so this overload doesn't require one.
  *
  * @param queue - The queue definition or queue with infrastructure to bind
- * @param exchange - The fanout exchange definition
+ * @param exchange - The fanout or headers exchange definition
  * @param options - Optional binding configuration
  * @param options.arguments - Additional AMQP arguments for the binding
  * @returns A queue binding definition
  *
  * @example
  * ```typescript
- * const logsQueue = defineQueue('logs-queue', { durable: true });
- * const logsExchange = defineExchange('logs', 'fanout', { durable: true });
+ * const logsQueue = defineQueue('logs-queue');
+ * const logsExchange = defineExchange('logs', { type: 'fanout' });
  *
  * const binding = defineQueueBinding(logsQueue, logsExchange);
  * ```
  */
-declare function defineQueueBinding(queue: QueueEntry, exchange: FanoutExchangeDefinition, options?: Omit<Extract<QueueBindingDefinition, {
-  exchange: FanoutExchangeDefinition;
+declare function defineQueueBinding(queue: QueueEntry, exchange: FanoutExchangeDefinition | HeadersExchangeDefinition, options?: Omit<Extract<QueueBindingDefinition, {
+  exchange: FanoutExchangeDefinition | HeadersExchangeDefinition;
 }>, "type" | "queue" | "exchange" | "routingKey">): Extract<QueueBindingDefinition, {
-  exchange: FanoutExchangeDefinition;
+  exchange: FanoutExchangeDefinition | HeadersExchangeDefinition;
 }>;
 /**
  * Define a binding between a queue and a direct or topic exchange.
@@ -1665,8 +1553,8 @@ declare function defineQueueBinding(queue: QueueEntry, exchange: FanoutExchangeD
  *
  * @example
  * ```typescript
- * const orderQueue = defineQueue('order-processing', { durable: true });
- * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
+ * const orderQueue = defineQueue('order-processing');
+ * const ordersExchange = defineExchange('orders');
  *
  * // Bind with exact routing key
  * const binding = defineQueueBinding(orderQueue, ordersExchange, {
@@ -1687,28 +1575,28 @@ declare function defineQueueBinding(queue: QueueEntry, exchange: DirectExchangeD
 /**
  * Define a binding between two exchanges (exchange-to-exchange routing).
  *
- * Binds a destination exchange to a fanout source exchange.
+ * Binds a destination exchange to a fanout or headers source exchange.
  * Messages published to the source exchange will be forwarded to the destination exchange.
- * Fanout exchanges ignore routing keys, so this overload doesn't require one.
+ * Fanout and headers exchanges ignore routing keys, so this overload doesn't require one.
  *
  * @param destination - The destination exchange definition
- * @param source - The fanout source exchange definition
+ * @param source - The fanout or headers source exchange definition
  * @param options - Optional binding configuration
  * @param options.arguments - Additional AMQP arguments for the binding
  * @returns An exchange binding definition
  *
  * @example
  * ```typescript
- * const sourceExchange = defineExchange('logs', 'fanout', { durable: true });
- * const destExchange = defineExchange('all-logs', 'fanout', { durable: true });
+ * const sourceExchange = defineExchange('logs', { type: 'fanout' });
+ * const destExchange = defineExchange('all-logs', { type: 'fanout' });
  *
  * const binding = defineExchangeBinding(destExchange, sourceExchange);
  * ```
  */
-declare function defineExchangeBinding(destination: ExchangeDefinition, source: FanoutExchangeDefinition, options?: Omit<Extract<ExchangeBindingDefinition, {
-  source: FanoutExchangeDefinition;
+declare function defineExchangeBinding(destination: ExchangeDefinition, source: FanoutExchangeDefinition | HeadersExchangeDefinition, options?: Omit<Extract<ExchangeBindingDefinition, {
+  source: FanoutExchangeDefinition | HeadersExchangeDefinition;
 }>, "type" | "source" | "destination" | "routingKey">): Extract<ExchangeBindingDefinition, {
-  source: FanoutExchangeDefinition;
+  source: FanoutExchangeDefinition | HeadersExchangeDefinition;
 }>;
 /**
  * Define a binding between two exchanges (exchange-to-exchange routing).
@@ -1725,8 +1613,8 @@ declare function defineExchangeBinding(destination: ExchangeDefinition, source:
  *
  * @example
  * ```typescript
- * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
- * const importantExchange = defineExchange('important-orders', 'topic', { durable: true });
+ * const ordersExchange = defineExchange('orders');
+ * const importantExchange = defineExchange('important-orders');
  *
  * // Forward only high-value orders
  * const binding = defineExchangeBinding(importantExchange, ordersExchange, {
@@ -1742,10 +1630,11 @@ declare function defineExchangeBinding(destination: ExchangeDefinition, source:
 //#endregion
 //#region src/builder/publisher.d.ts
 /**
- * Define a message publisher for a fanout exchange.
+ * Define a message publisher for a fanout or headers exchange.
  *
  * A publisher sends messages to an exchange. For fanout exchanges, messages are broadcast
- * to all bound queues regardless of routing key, so no routing key is required.
+ * to all bound queues regardless of routing key, so no routing key is required. For headers exchanges,
+ * routing is based on message headers rather than routing keys, so no routing key is required either.
  *
  * The message schema is validated when publishing to ensure type safety.
  *
@@ -1762,7 +1651,7 @@ declare function defineExchangeBinding(destination: ExchangeDefinition, source:
  * - You want automatic schema consistency between publisher and consumers
  * - You're building event-driven architectures
  *
- * @param exchange - The fanout exchange definition to publish to
+ * @param exchange - The fanout or headers exchange definition to publish to
  * @param message - The message definition with payload schema
  * @param options - Optional publisher configuration
  * @returns A publisher definition with inferred message types
@@ -1771,7 +1660,7 @@ declare function defineExchangeBinding(destination: ExchangeDefinition, source:
  * ```typescript
  * import { z } from 'zod';
  *
- * const logsExchange = defineExchange('logs', 'fanout', { durable: true });
+ * const logsExchange = defineExchange('logs', { type: 'fanout' });
  * const logMessage = defineMessage(
  *   z.object({
  *     level: z.enum(['info', 'warn', 'error']),
@@ -1786,10 +1675,10 @@ declare function defineExchangeBinding(destination: ExchangeDefinition, source:
  * @see defineEventPublisher - For event-driven patterns with automatic schema consistency
  * @see defineCommandConsumer - For task queue patterns with automatic schema consistency
  */
-declare function definePublisher<TMessage extends MessageDefinition>(exchange: FanoutExchangeDefinition, message: TMessage, options?: Omit<Extract<PublisherDefinition<TMessage>, {
-  exchange: FanoutExchangeDefinition;
+declare function definePublisher<TMessage extends MessageDefinition>(exchange: FanoutExchangeDefinition | HeadersExchangeDefinition, message: TMessage, options?: Omit<Extract<PublisherDefinition<TMessage>, {
+  exchange: FanoutExchangeDefinition | HeadersExchangeDefinition;
 }>, "exchange" | "message" | "routingKey">): Extract<PublisherDefinition<TMessage>, {
-  exchange: FanoutExchangeDefinition;
+  exchange: FanoutExchangeDefinition | HeadersExchangeDefinition;
 }>;
 /**
  * Define a message publisher for a direct or topic exchange.
@@ -1822,7 +1711,7 @@ declare function definePublisher<TMessage extends MessageDefinition>(exchange: F
  * ```typescript
  * import { z } from 'zod';
  *
- * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
+ * const ordersExchange = defineExchange('orders');
  * const orderMessage = defineMessage(
  *   z.object({
  *     orderId: z.string().uuid(),
@@ -1911,7 +1800,7 @@ declare function extractConsumer(entry: ConsumerEntry): ConsumerDefinition;
  * ```typescript
  * import { z } from 'zod';
  *
- * const orderQueue = defineQueue('order-processing', { durable: true });
+ * const orderQueue = defineQueue('order-processing');
  * const orderMessage = defineMessage(
  *   z.object({
  *     orderId: z.string().uuid(),
@@ -1970,12 +1859,11 @@ declare function defineConsumer<TMessage extends MessageDefinition>(queue: Queue
  * import { z } from 'zod';
  *
  * // Define resources
- * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
- * const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
+ * const ordersExchange = defineExchange('orders');
+ * const dlx = defineExchange('orders-dlx', { type: 'direct' });
  * const orderQueue = defineQueue('order-processing', {
  *   deadLetter: { exchange: dlx },
- *   retry: { mode: 'quorum-native' },
- *   deliveryLimit: 3,
+ *   retry: { mode: 'immediate-requeue', maxRetries: 3 },
  * });
  * const orderMessage = defineMessage(
  *   z.object({
@@ -2097,7 +1985,7 @@ type MatchingRoutingKey<Pattern extends string, Key extends string> = RoutingKey
  *
  * @template TMessage - The message definition
  * @template TExchange - The exchange definition
- * @template TRoutingKey - The routing key type (undefined for fanout)
+ * @template TRoutingKey - The routing key type (undefined for fanout and headers exchanges)
  */
 type EventPublisherConfig<TMessage extends MessageDefinition, TExchange extends ExchangeDefinition, TRoutingKey extends string | undefined = undefined> = {
   /** Discriminator to identify this as an event publisher config */__brand: "EventPublisherConfig"; /** The exchange to publish to */
@@ -2115,13 +2003,12 @@ type EventPublisherConfig<TMessage extends MessageDefinition, TExchange extends
  *
  * @template TMessage - The message definition
  */
-type EventConsumerResult<TMessage extends MessageDefinition, TExchange extends ExchangeDefinition = ExchangeDefinition, TQueue extends QueueDefinition = QueueDefinition, TDlxExchange extends ExchangeDefinition | undefined = ExchangeDefinition | undefined, TExchangeBinding extends ExchangeBindingDefinition | undefined = ExchangeBindingDefinition | undefined, TBridgeExchange extends ExchangeDefinition | undefined = ExchangeDefinition | undefined> = {
+type EventConsumerResult<TMessage extends MessageDefinition, TExchange extends ExchangeDefinition = ExchangeDefinition, TQueue extends QueueEntry = QueueEntry, TExchangeBinding extends ExchangeBindingDefinition | undefined = ExchangeBindingDefinition | undefined, TBridgeExchange extends ExchangeDefinition | undefined = ExchangeDefinition | undefined> = {
   /** Discriminator to identify this as an event consumer result */__brand: "EventConsumerResult"; /** The consumer definition for processing messages */
   consumer: ConsumerDefinition<TMessage>; /** The binding connecting the queue to the exchange */
   binding: QueueBindingDefinition; /** The source exchange this consumer subscribes to */
   exchange: TExchange; /** The queue this consumer reads from */
-  queue: TQueue; /** The dead letter exchange from the queue, if configured */
-  deadLetterExchange: TDlxExchange; /** The exchange-to-exchange binding when bridging, if configured */
+  queue: TQueue; /** The exchange-to-exchange binding when bridging, if configured */
   exchangeBinding: TExchangeBinding; /** The bridge (local domain) exchange when bridging, if configured */
   bridgeExchange: TBridgeExchange;
 };
@@ -2133,11 +2020,46 @@ type EventConsumerResult<TMessage extends MessageDefinition, TExchange extends E
  *
  * @param exchange - The fanout exchange to publish to
  * @param message - The message definition (schema and metadata)
+ * @param options - Optional binding configuration
+ * @param options.arguments - Additional AMQP arguments
+ * @returns An event publisher configuration
+ *
+ * @example
+ * ```typescript
+ * const logsExchange = defineExchange('logs', { type: 'fanout' });
+ * const logMessage = defineMessage(z.object({
+ *   level: z.enum(['info', 'warn', 'error']),
+ *   message: z.string(),
+ * }));
+ *
+ * // Create event publisher
+ * const logEvent = defineEventPublisher(logsExchange, logMessage);
+ *
+ * // Multiple consumers can subscribe
+ * const { consumer: fileConsumer, binding: fileBinding } =
+ *   defineEventConsumer(logEvent, fileLogsQueue);
+ * const { consumer: alertConsumer, binding: alertBinding } =
+ *   defineEventConsumer(logEvent, alertsQueue);
+ * ```
+ */
+declare function defineEventPublisher<TMessage extends MessageDefinition, TExchange extends FanoutExchangeDefinition>(exchange: TExchange, message: TMessage, options?: {
+  arguments?: Record<string, unknown>;
+}): EventPublisherConfig<TMessage, TExchange, undefined>;
+/**
+ * Define an event publisher for broadcasting messages via headers exchange.
+ *
+ * Events are published without knowing who consumes them. Multiple consumers
+ * can subscribe to the same event using `defineEventConsumer`.
+ *
+ * @param exchange - The headers exchange to publish to
+ * @param message - The message definition (schema and metadata)
+ * @param options - Optional binding configuration
+ * @param options.arguments - Additional AMQP arguments
  * @returns An event publisher configuration
  *
  * @example
  * ```typescript
- * const logsExchange = defineExchange('logs', 'fanout', { durable: true });
+ * const logsExchange = defineExchange('logs', { type: 'headers' });
  * const logMessage = defineMessage(z.object({
  *   level: z.enum(['info', 'warn', 'error']),
  *   message: z.string(),
@@ -2153,7 +2075,9 @@ type EventConsumerResult<TMessage extends MessageDefinition, TExchange extends E
  *   defineEventConsumer(logEvent, alertsQueue);
  * ```
  */
-declare function defineEventPublisher<TMessage extends MessageDefinition, TExchange extends FanoutExchangeDefinition>(exchange: TExchange, message: TMessage): EventPublisherConfig<TMessage, TExchange, undefined>;
+declare function defineEventPublisher<TMessage extends MessageDefinition, TExchange extends HeadersExchangeDefinition>(exchange: TExchange, message: TMessage, options?: {
+  arguments?: Record<string, unknown>;
+}): EventPublisherConfig<TMessage, TExchange, undefined>;
 /**
  * Define an event publisher for broadcasting messages via direct exchange.
  *
@@ -2169,7 +2093,7 @@ declare function defineEventPublisher<TMessage extends MessageDefinition, TExcha
  *
  * @example
  * ```typescript
- * const tasksExchange = defineExchange('tasks', 'direct', { durable: true });
+ * const tasksExchange = defineExchange('tasks', { type: 'direct' });
  * const taskMessage = defineMessage(z.object({ taskId: z.string() }));
  *
  * const taskEvent = defineEventPublisher(tasksExchange, taskMessage, {
@@ -2196,7 +2120,7 @@ declare function defineEventPublisher<TMessage extends MessageDefinition, TRouti
  *
  * @example
  * ```typescript
- * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
+ * const ordersExchange = defineExchange('orders', { type: 'topic' });
  * const orderMessage = defineMessage(z.object({
  *   orderId: z.string(),
  *   amount: z.number(),
@@ -2229,12 +2153,30 @@ declare function defineEventPublisher<TMessage extends MessageDefinition, TRouti
  * @param queue - The queue that will receive messages
  * @param options - Binding configuration with required bridgeExchange
  * @param options.bridgeExchange - The fanout bridge exchange (must be fanout to match source)
+ * @param options.arguments - Additional AMQP arguments
  * @returns An object with the consumer definition, queue binding, and exchange binding
  */
 declare function defineEventConsumer<TMessage extends MessageDefinition, TExchange extends FanoutExchangeDefinition, TQueueEntry extends QueueEntry, TBridgeExchange extends FanoutExchangeDefinition>(eventPublisher: EventPublisherConfig<TMessage, TExchange, undefined>, queue: TQueueEntry, options: {
   bridgeExchange: TBridgeExchange;
   arguments?: Record<string, unknown>;
-}): EventConsumerResult<TMessage, TExchange, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>, ExchangeBindingDefinition, TBridgeExchange>;
+}): EventConsumerResult<TMessage, TExchange, TQueueEntry, ExchangeBindingDefinition, TBridgeExchange>;
+/**
+ * Create a consumer that subscribes to an event from a headers exchange via a bridge exchange.
+ *
+ * When `bridgeExchange` is provided, the queue binds to the bridge exchange instead of the
+ * source exchange, and an exchange-to-exchange binding is created from the source to the bridge.
+ *
+ * @param eventPublisher - The event publisher configuration
+ * @param queue - The queue that will receive messages
+ * @param options - Binding configuration with required bridgeExchange
+ * @param options.bridgeExchange - The headers bridge exchange (must be headers to match source)
+ * @param options.arguments - Additional AMQP arguments
+ * @returns An object with the consumer definition, queue binding, and exchange binding
+ */
+declare function defineEventConsumer<TMessage extends MessageDefinition, TExchange extends HeadersExchangeDefinition, TQueueEntry extends QueueEntry, TBridgeExchange extends HeadersExchangeDefinition>(eventPublisher: EventPublisherConfig<TMessage, TExchange, undefined>, queue: TQueueEntry, options: {
+  bridgeExchange: TBridgeExchange;
+  arguments?: Record<string, unknown>;
+}): EventConsumerResult<TMessage, TExchange, TQueueEntry, ExchangeBindingDefinition, TBridgeExchange>;
 /**
  * Create a consumer that subscribes to an event from a direct exchange via a bridge exchange.
  *
@@ -2242,12 +2184,13 @@ declare function defineEventConsumer<TMessage extends MessageDefinition, TExchan
  * @param queue - The queue that will receive messages
  * @param options - Binding configuration with required bridgeExchange
  * @param options.bridgeExchange - The bridge exchange (must be direct or topic to preserve routing keys)
+ * @param options.arguments - Additional AMQP arguments
  * @returns An object with the consumer definition, queue binding, and exchange binding
  */
 declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutingKey extends string, TExchange extends DirectExchangeDefinition, TQueueEntry extends QueueEntry, TBridgeExchange extends DirectExchangeDefinition | TopicExchangeDefinition>(eventPublisher: EventPublisherConfig<TMessage, TExchange, TRoutingKey>, queue: TQueueEntry, options: {
   bridgeExchange: TBridgeExchange;
   arguments?: Record<string, unknown>;
-}): EventConsumerResult<TMessage, TExchange, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>, ExchangeBindingDefinition, TBridgeExchange>;
+}): EventConsumerResult<TMessage, TExchange, TQueueEntry, ExchangeBindingDefinition, TBridgeExchange>;
 /**
  * Create a consumer that subscribes to an event from a topic exchange via a bridge exchange.
  *
@@ -2256,19 +2199,21 @@ declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutin
  * @param options - Binding configuration with required bridgeExchange
  * @param options.bridgeExchange - The bridge exchange (must be direct or topic to preserve routing keys)
  * @param options.routingKey - Override routing key with pattern (defaults to publisher's key)
+ * @param options.arguments - Additional AMQP arguments
  * @returns An object with the consumer definition, queue binding, and exchange binding
  */
 declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutingKey extends string, TExchange extends TopicExchangeDefinition, TQueueEntry extends QueueEntry, TBridgeExchange extends DirectExchangeDefinition | TopicExchangeDefinition, TConsumerRoutingKey extends string = TRoutingKey>(eventPublisher: EventPublisherConfig<TMessage, TExchange, TRoutingKey>, queue: TQueueEntry, options: {
   bridgeExchange: TBridgeExchange;
   routingKey?: BindingPattern<TConsumerRoutingKey>;
   arguments?: Record<string, unknown>;
-}): EventConsumerResult<TMessage, TExchange, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>, ExchangeBindingDefinition, TBridgeExchange>;
+}): EventConsumerResult<TMessage, TExchange, TQueueEntry, ExchangeBindingDefinition, TBridgeExchange>;
 /**
  * Create a consumer that subscribes to an event from a fanout exchange.
  *
  * @param eventPublisher - The event publisher configuration
  * @param queue - The queue that will receive messages
  * @param options - Optional binding configuration
+ * @param options.arguments - Additional AMQP arguments
  * @returns An object with the consumer definition and binding
  *
  * @example
@@ -2279,18 +2224,37 @@ declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutin
  */
 declare function defineEventConsumer<TMessage extends MessageDefinition, TExchange extends FanoutExchangeDefinition, TQueueEntry extends QueueEntry>(eventPublisher: EventPublisherConfig<TMessage, TExchange, undefined>, queue: TQueueEntry, options?: {
   arguments?: Record<string, unknown>;
-}): EventConsumerResult<TMessage, TExchange, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
+}): EventConsumerResult<TMessage, TExchange, TQueueEntry>;
+/**
+ * Create a consumer that subscribes to an event from a headers exchange.
+ *
+ * @param eventPublisher - The event publisher configuration
+ * @param queue - The queue that will receive messages
+ * @param options - Optional binding configuration
+ * @param options.arguments - Additional AMQP arguments
+ * @returns An object with the consumer definition and binding
+ *
+ * @example
+ * ```typescript
+ * const logEvent = defineEventPublisher(logsExchange, logMessage);
+ * const { consumer, binding } = defineEventConsumer(logEvent, logsQueue);
+ * ```
+ */
+declare function defineEventConsumer<TMessage extends MessageDefinition, TExchange extends HeadersExchangeDefinition, TQueueEntry extends QueueEntry>(eventPublisher: EventPublisherConfig<TMessage, TExchange, undefined>, queue: TQueueEntry, options?: {
+  arguments?: Record<string, unknown>;
+}): EventConsumerResult<TMessage, TExchange, TQueueEntry>;
 /**
  * Create a consumer that subscribes to an event from a direct exchange.
  *
  * @param eventPublisher - The event publisher configuration
  * @param queue - The queue that will receive messages
  * @param options - Optional binding configuration
+ * @param options.arguments - Additional AMQP arguments
  * @returns An object with the consumer definition and binding
  */
 declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutingKey extends string, TExchange extends DirectExchangeDefinition, TQueueEntry extends QueueEntry>(eventPublisher: EventPublisherConfig<TMessage, TExchange, TRoutingKey>, queue: TQueueEntry, options?: {
   arguments?: Record<string, unknown>;
-}): EventConsumerResult<TMessage, TExchange, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
+}): EventConsumerResult<TMessage, TExchange, TQueueEntry>;
 /**
  * Create a consumer that subscribes to an event from a topic exchange.
  *
@@ -2301,6 +2265,7 @@ declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutin
  * @param queue - The queue that will receive messages
  * @param options - Optional binding configuration
  * @param options.routingKey - Override routing key with pattern (defaults to publisher's key)
+ * @param options.arguments - Additional AMQP arguments
  * @returns An object with the consumer definition and binding
  *
  * @example
@@ -2321,7 +2286,7 @@ declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutin
 declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutingKey extends string, TExchange extends TopicExchangeDefinition, TQueueEntry extends QueueEntry, TConsumerRoutingKey extends string = TRoutingKey>(eventPublisher: EventPublisherConfig<TMessage, TExchange, TRoutingKey>, queue: TQueueEntry, options?: {
   routingKey?: BindingPattern<TConsumerRoutingKey>;
   arguments?: Record<string, unknown>;
-}): EventConsumerResult<TMessage, TExchange, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
+}): EventConsumerResult<TMessage, TExchange, TQueueEntry>;
 /**
  * Type guard to check if a value is an EventPublisherConfig.
  *
@@ -2346,15 +2311,14 @@ declare function isEventConsumerResult(value: unknown): value is EventConsumerRe
  *
  * @template TMessage - The message definition
  * @template TExchange - The exchange definition
- * @template TRoutingKey - The routing key type (undefined for fanout)
+ * @template TRoutingKey - The routing key type (undefined for fanout and headers exchanges)
  */
-type CommandConsumerConfig<TMessage extends MessageDefinition, TExchange extends ExchangeDefinition, TRoutingKey extends string | undefined = undefined, TQueue extends QueueDefinition = QueueDefinition, TDlxExchange extends ExchangeDefinition | undefined = ExchangeDefinition | undefined> = {
+type CommandConsumerConfig<TMessage extends MessageDefinition, TExchange extends ExchangeDefinition, TRoutingKey extends string | undefined = undefined, TQueue extends QueueEntry = QueueEntry> = {
   /** Discriminator to identify this as a command consumer config */__brand: "CommandConsumerConfig"; /** The consumer definition for processing commands */
   consumer: ConsumerDefinition<TMessage>; /** The binding connecting the queue to the exchange */
   binding: QueueBindingDefinition; /** The exchange that receives commands */
   exchange: TExchange; /** The queue this consumer reads from */
-  queue: TQueue; /** The dead letter exchange from the queue, if configured */
-  deadLetterExchange: TDlxExchange; /** The message definition */
+  queue: TQueue; /** The message definition */
   message: TMessage; /** The routing key pattern for the binding */
   routingKey: TRoutingKey;
 };
@@ -2384,11 +2348,41 @@ type BridgedPublisherConfig<TMessage extends MessageDefinition, TBridgeExchange
  * @param queue - The queue that will receive commands
  * @param exchange - The fanout exchange that routes commands
  * @param message - The message definition (schema and metadata)
+ * @param options - Optional binding configuration
+ * @param options.arguments - Additional AMQP arguments
+ * @returns A command consumer configuration
+ *
+ * @example
+ * ```typescript
+ * const tasksExchange = defineExchange('tasks', { type: 'fanout' });
+ * const taskMessage = defineMessage(z.object({ taskId: z.string() }));
+ *
+ * // Consumer owns the queue
+ * const executeTask = defineCommandConsumer(taskQueue, tasksExchange, taskMessage);
+ *
+ * // Publishers send commands to it
+ * const sendTask = defineCommandPublisher(executeTask);
+ * ```
+ */
+declare function defineCommandConsumer<TMessage extends MessageDefinition, TQueueEntry extends QueueEntry, TExchange extends FanoutExchangeDefinition>(queue: TQueueEntry, exchange: TExchange, message: TMessage, options?: {
+  arguments?: Record<string, unknown>;
+}): CommandConsumerConfig<TMessage, TExchange, undefined, TQueueEntry>;
+/**
+ * Define a command consumer for receiving commands via headers exchange.
+ *
+ * Commands are sent by publishers to a specific queue. The consumer "owns" the
+ * queue and defines what commands it accepts.
+ *
+ * @param queue - The queue that will receive commands
+ * @param exchange - The headers exchange that routes commands
+ * @param message - The message definition (schema and metadata)
+ * @param options - Optional binding configuration
+ * @param options.arguments - Additional AMQP arguments
  * @returns A command consumer configuration
  *
  * @example
  * ```typescript
- * const tasksExchange = defineExchange('tasks', 'fanout', { durable: true });
+ * const tasksExchange = defineExchange('tasks', { type: 'headers' });
  * const taskMessage = defineMessage(z.object({ taskId: z.string() }));
  *
  * // Consumer owns the queue
@@ -2398,7 +2392,9 @@ type BridgedPublisherConfig<TMessage extends MessageDefinition, TBridgeExchange
  * const sendTask = defineCommandPublisher(executeTask);
  * ```
  */
-declare function defineCommandConsumer<TMessage extends MessageDefinition, TQueueEntry extends QueueEntry, TExchange extends FanoutExchangeDefinition>(queue: TQueueEntry, exchange: TExchange, message: TMessage): CommandConsumerConfig<TMessage, TExchange, undefined, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
+declare function defineCommandConsumer<TMessage extends MessageDefinition, TQueueEntry extends QueueEntry, TExchange extends HeadersExchangeDefinition>(queue: TQueueEntry, exchange: TExchange, message: TMessage, options?: {
+  arguments?: Record<string, unknown>;
+}): CommandConsumerConfig<TMessage, TExchange, undefined, TQueueEntry>;
 /**
  * Define a command consumer for receiving commands via direct exchange.
  *
@@ -2415,7 +2411,7 @@ declare function defineCommandConsumer<TMessage extends MessageDefinition, TQueu
  *
  * @example
  * ```typescript
- * const tasksExchange = defineExchange('tasks', 'direct', { durable: true });
+ * const tasksExchange = defineExchange('tasks', { type: 'direct' });
  * const taskMessage = defineMessage(z.object({ taskId: z.string() }));
  *
  * const executeTask = defineCommandConsumer(taskQueue, tasksExchange, taskMessage, {
@@ -2428,7 +2424,7 @@ declare function defineCommandConsumer<TMessage extends MessageDefinition, TQueu
 declare function defineCommandConsumer<TMessage extends MessageDefinition, TRoutingKey extends string, TQueueEntry extends QueueEntry, TExchange extends DirectExchangeDefinition>(queue: TQueueEntry, exchange: TExchange, message: TMessage, options: {
   routingKey: RoutingKey<TRoutingKey>;
   arguments?: Record<string, unknown>;
-}): CommandConsumerConfig<TMessage, TExchange, TRoutingKey, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
+}): CommandConsumerConfig<TMessage, TExchange, TRoutingKey, TQueueEntry>;
 /**
  * Define a command consumer for receiving commands via topic exchange.
  *
@@ -2445,7 +2441,7 @@ declare function defineCommandConsumer<TMessage extends MessageDefinition, TRout
  *
  * @example
  * ```typescript
- * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
+ * const ordersExchange = defineExchange('orders', { type: 'topic' });
  * const orderMessage = defineMessage(z.object({ orderId: z.string() }));
  *
  * // Consumer uses pattern to receive multiple command types
@@ -2465,18 +2461,29 @@ declare function defineCommandConsumer<TMessage extends MessageDefinition, TRout
 declare function defineCommandConsumer<TMessage extends MessageDefinition, TRoutingKey extends string, TQueueEntry extends QueueEntry, TExchange extends TopicExchangeDefinition>(queue: TQueueEntry, exchange: TExchange, message: TMessage, options: {
   routingKey: BindingPattern<TRoutingKey>;
   arguments?: Record<string, unknown>;
-}): CommandConsumerConfig<TMessage, TExchange, TRoutingKey, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
+}): CommandConsumerConfig<TMessage, TExchange, TRoutingKey, TQueueEntry>;
 /**
  * Create a bridged publisher that sends commands to a fanout exchange consumer via a bridge exchange.
  *
  * @param commandConsumer - The command consumer configuration
  * @param options - Configuration with required bridgeExchange
- * @param options.bridgeExchange - The local domain exchange to bridge through
+ * @param options.bridgeExchange - The local domain exchange to bridge through (must be fanout to match target)
  * @returns A bridged publisher configuration
  */
 declare function defineCommandPublisher<TMessage extends MessageDefinition, TExchange extends FanoutExchangeDefinition, TBridgeExchange extends FanoutExchangeDefinition>(commandConsumer: CommandConsumerConfig<TMessage, TExchange, undefined>, options: {
   bridgeExchange: TBridgeExchange;
 }): BridgedPublisherConfig<TMessage, TBridgeExchange, TExchange>;
+/**
+ * Create a bridged publisher that sends commands to a headers exchange consumer via a bridge exchange.
+ *
+ * @param commandConsumer - The command consumer configuration
+ * @param options - Configuration with required bridgeExchange
+ * @param options.bridgeExchange - The local domain exchange to bridge through (must be headers to match target)
+ * @returns A bridged publisher configuration
+ */
+declare function defineCommandPublisher<TMessage extends MessageDefinition, TExchange extends HeadersExchangeDefinition, TBridgeExchange extends HeadersExchangeDefinition>(commandConsumer: CommandConsumerConfig<TMessage, TExchange, undefined>, options: {
+  bridgeExchange: TBridgeExchange;
+}): BridgedPublisherConfig<TMessage, TBridgeExchange, TExchange>;
 /**
  * Create a bridged publisher that sends commands to a direct exchange consumer via a bridge exchange.
  *
@@ -2517,6 +2524,22 @@ declare function defineCommandPublisher<TMessage extends MessageDefinition>(comm
   message: TMessage;
   exchange: FanoutExchangeDefinition;
 };
+/**
+ * Create a publisher that sends commands to a headers exchange consumer.
+ *
+ * @param commandConsumer - The command consumer configuration
+ * @returns A publisher definition
+ *
+ * @example
+ * ```typescript
+ * const executeTask = defineCommandConsumer(taskQueue, headersExchange, taskMessage);
+ * const sendTask = defineCommandPublisher(executeTask);
+ * ```
+ */
+declare function defineCommandPublisher<TMessage extends MessageDefinition>(commandConsumer: CommandConsumerConfig<TMessage, HeadersExchangeDefinition, undefined>): {
+  message: TMessage;
+  exchange: HeadersExchangeDefinition;
+};
 /**
  * Create a publisher that sends commands to a direct exchange consumer.
  *
@@ -2535,7 +2558,7 @@ declare function defineCommandPublisher<TMessage extends MessageDefinition, TRou
  * optionally specify a concrete routing key that matches the pattern.
  *
  * @param commandConsumer - The command consumer configuration
- * @param options - Optional publisher configuration
+ * @param options - Optional binding configuration
  * @param options.routingKey - Override routing key (must match consumer's pattern)
  * @returns A publisher definition
  *
@@ -2574,72 +2597,84 @@ declare function isCommandConsumerConfig(value: unknown): value is CommandConsum
  */
 declare function isBridgedPublisherConfig(value: unknown): value is BridgedPublisherConfig<MessageDefinition, ExchangeDefinition, ExchangeDefinition>;
 //#endregion
-//#region src/builder/ttl-backoff.d.ts
+//#region src/builder/rpc.d.ts
 /**
- * Result type for TTL-backoff retry infrastructure builder.
+ * Define an RPC operation: a request/response pair flowing over a request
+ * queue with replies routed back via RabbitMQ direct reply-to.
+ *
+ * RPC is bidirectional on both ends — the worker handler consumes the request
+ * and produces the response; `client.call(name, request, options)` publishes
+ * the request and awaits the typed response. Both sides share the same
+ * definition, so request and response schemas cannot drift between them.
+ *
+ * Plug the result into `defineContract({ rpcs: { name: ... } })`. RPCs do not
+ * appear in `publishers` or `consumers`.
+ *
+ * @param queue - The queue that receives RPC requests. The queue name is
+ *   used as the routing key on the AMQP default direct exchange.
+ * @param messages.request - Schema validated against incoming request payloads
+ *   (server side) and outgoing requests (client side).
+ * @param messages.response - Schema validated against handler return values
+ *   (server side) and incoming replies (client side).
+ *
+ * @example
+ * ```typescript
+ * import { defineQueue, defineMessage, defineRpc, defineContract } from '@amqp-contract/contract';
+ * import { z } from 'zod';
+ *
+ * const calculate = defineRpc(defineQueue('rpc.calculate'), {
+ *   request: defineMessage(z.object({ a: z.number(), b: z.number() })),
+ *   response: defineMessage(z.object({ sum: z.number() })),
+ * });
+ *
+ * const contract = defineContract({ rpcs: { calculate } });
  *
- * Contains the wait queue and bindings needed for TTL-backoff retry.
+ * // Server (worker): handler returns the typed response
+ * //   handlers: { calculate: ({ payload }) => Future.value(Result.Ok({ sum: payload.a + payload.b })) }
+ *
+ * // Client: typed call with required timeout
+ * //   const result = await client.call('calculate', { a: 1, b: 2 }, { timeoutMs: 5_000 }).toPromise();
+ * ```
  */
-type TtlBackoffRetryInfrastructure = {
-  /**
-   * The wait queue for holding messages during backoff delay.
-   * This is a classic queue with a dead letter exchange pointing back to the main queue.
-   */
-  waitQueue: QueueDefinition;
-  /**
-   * Binding that routes failed messages to the wait queue.
-   */
-  waitQueueBinding: QueueBindingDefinition;
-  /**
-   * Binding that routes retried messages back to the main queue.
-   */
-  mainQueueRetryBinding: QueueBindingDefinition;
-};
+declare function defineRpc<TRequestMessage extends MessageDefinition, TResponseMessage extends MessageDefinition, TQueue extends QueueEntry>(queue: TQueue, messages: {
+  request: TRequestMessage;
+  response: TResponseMessage;
+}): RpcDefinition<TRequestMessage, TResponseMessage, TQueue>;
+//#endregion
+//#region src/builder/ttl-backoff.d.ts
 /**
- * Create TTL-backoff retry infrastructure for a queue.
+ * Type guard to check if a queue entry is a QueueWithTtlBackoffInfrastructure.
+ *
+ * When you configure a queue with TTL-backoff retry,
+ * `defineQueue` returns a `QueueWithTtlBackoffInfrastructure` instead of a plain
+ * `QueueDefinition`. This type guard helps you distinguish between the two.
  *
- * This builder helper generates the wait queue and bindings needed for TTL-backoff retry.
- * The generated infrastructure can be spread into a contract definition.
+ * **When to use:**
+ * - When you need to check the type of a queue entry at runtime
+ * - When writing generic code that handles both plain queues and infrastructure wrappers
  *
- * TTL-backoff retry works by:
- * 1. Failed messages are sent to the DLX with routing key `{queueName}-wait`
- * 2. The wait queue receives these messages and holds them for a TTL period
- * 3. After TTL expires, messages are dead-lettered back to the DLX with routing key `{queueName}`
- * 4. The main queue receives the retried message via its binding to the DLX
+ * **Related functions:**
+ * - `extractQueue()` - Use this to get the underlying queue definition from either type
  *
- * @param queue - The main queue definition (must have deadLetter configured)
- * @param options - Optional configuration for the wait queue
- * @param options.waitQueueDurable - Whether the wait queue should be durable (default: same as main queue)
- * @returns TTL-backoff retry infrastructure containing wait queue and bindings
- * @throws {Error} If the queue does not have a dead letter exchange configured
+ * @param entry - The queue entry to check
+ * @returns True if the entry is a QueueWithTtlBackoffInfrastructure, false otherwise
  *
  * @example
  * ```typescript
- * const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
- * const orderQueue = defineQueue('order-processing', {
- *   type: 'quorum',
- *   deadLetter: { exchange: dlx },
- *   retry: {
- *     mode: 'ttl-backoff',
- *     maxRetries: 5,
- *     initialDelayMs: 1000,
- *   },
- * });
- *
- * // Infrastructure is auto-extracted when using defineContract:
- * const contract = defineContract({
- *   publishers: { ... },
- *   consumers: { processOrder: defineEventConsumer(event, extractQueue(orderQueue)) },
+ * const queue = defineQueue('orders', {
+ *   retry: { mode: 'ttl-backoff' },
  * });
- * // contract.queues includes the wait queue, contract.bindings includes retry bindings
  *
- * // Or generate manually for advanced use cases:
- * const retryInfra = defineTtlBackoffRetryInfrastructure(orderQueue);
+ * if (isQueueWithTtlBackoffInfrastructure(queue)) {
+ *   // queue has .queue, .waitQueue, .waitQueueBinding, .retryQueueBinding, .waitExchange, .retryExchange
+ *   console.log('Wait queue:', queue.waitQueue.name);
+ * } else {
+ *   // queue is a plain QueueDefinition
+ *   console.log('Queue:', queue.name);
+ * }
  * ```
  */
-declare function defineTtlBackoffRetryInfrastructure(queueEntry: QueueEntry, options?: {
-  waitQueueDurable?: boolean;
-}): TtlBackoffRetryInfrastructure;
+declare function isQueueWithTtlBackoffInfrastructure(entry: QueueEntry): entry is QueueWithTtlBackoffInfrastructure;
 //#endregion
-export { type AnySchema, type BaseExchangeDefinition, type BindingDefinition, type BindingPattern, type BridgedPublisherConfig, type BridgedPublisherConfigBase, type ClassicQueueDefinition, type ClassicQueueOptions, type CommandConsumerConfig, type CommandConsumerConfigBase, type CompressionAlgorithm, type ConsumerDefinition, type ConsumerEntry, type ContractDefinition, type ContractDefinitionInput, type ContractOutput, type DeadLetterConfig, type DefineQueueOptions, type DefineQuorumQueueOptions, type DefineTtlBackoffQueueOptions, type DirectExchangeDefinition, type EventConsumerResult, type EventConsumerResultBase, type EventPublisherConfig, type EventPublisherConfigBase, type ExchangeBindingDefinition, type ExchangeDefinition, type FanoutExchangeDefinition, type InferConsumerNames, type InferPublisherNames, type MatchingRoutingKey, type MessageDefinition, type PublisherDefinition, type PublisherEntry, type QueueBindingDefinition, type QueueDefinition, type QueueEntry, type QueueType, type QueueWithTtlBackoffInfrastructure, type QuorumNativeRetryOptions, type QuorumQueueDefinition, type QuorumQueueOptions, type ResolvedRetryOptions, type ResolvedTtlBackoffRetryOptions, type RoutingKey, type TopicExchangeDefinition, type TtlBackoffRetryInfrastructure, type TtlBackoffRetryOptions, defineCommandConsumer, defineCommandPublisher, defineConsumer, defineContract, defineEventConsumer, defineEventPublisher, defineExchange, defineExchangeBinding, defineMessage, definePublisher, defineQueue, defineQueueBinding, defineQuorumQueue, defineTtlBackoffQueue, defineTtlBackoffRetryInfrastructure, extractConsumer, extractQueue, isBridgedPublisherConfig, isCommandConsumerConfig, isEventConsumerResult, isEventPublisherConfig, isQueueWithTtlBackoffInfrastructure };
+export { type AnySchema, type BaseExchangeDefinition, type BindingDefinition, type BindingPattern, type BridgedPublisherConfig, type BridgedPublisherConfigBase, type ClassicQueueDefinition, type ClassicQueueOptions, type CommandConsumerConfig, type CommandConsumerConfigBase, type CompressionAlgorithm, type ConsumerDefinition, type ConsumerEntry, type ContractDefinition, type ContractDefinitionInput, type ContractOutput, type DeadLetterConfig, type DefineQueueOptions, type DirectExchangeDefinition, type EventConsumerResult, type EventConsumerResultBase, type EventPublisherConfig, type EventPublisherConfigBase, type ExchangeBindingDefinition, type ExchangeDefinition, type FanoutExchangeDefinition, type HeadersExchangeDefinition, type ImmediateRequeueRetryOptions, type InferConsumerNames, type InferPublisherNames, type InferRpcNames, type MatchingRoutingKey, type MessageDefinition, type PublisherDefinition, type PublisherEntry, type QueueBindingDefinition, type QueueDefinition, type QueueEntry, type QueueType, type QueueWithTtlBackoffInfrastructure, type QuorumQueueDefinition, type QuorumQueueOptions, type ResolvedImmediateRequeueRetryOptions, type ResolvedRetryOptions, type ResolvedTtlBackoffRetryOptions, type RoutingKey, type RpcDefinition, type TopicExchangeDefinition, type TtlBackoffRetryOptions, defineCommandConsumer, defineCommandPublisher, defineConsumer, defineContract, defineEventConsumer, defineEventPublisher, defineExchange, defineExchangeBinding, defineMessage, definePublisher, defineQueue, defineQueueBinding, defineRpc, extractConsumer, extractQueue, isBridgedPublisherConfig, isCommandConsumerConfig, isEventConsumerResult, isEventPublisherConfig, isQueueWithTtlBackoffInfrastructure };
 //# sourceMappingURL=index.d.cts.map