@amqp-contract/contract 0.13.0 → 0.15.0

package/dist/index.d.cts

@@ -1,7 +1,6 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/types.d.ts
-
 /**
  * Any schema that conforms to Standard Schema v1.
  *
@@ -350,11 +349,11 @@ type DefineQueueOptions = QuorumQueueOptions | ClassicQueueOptions;
  * An exchange receives messages from publishers and routes them to queues based on the exchange
  * type and routing rules. This type contains properties common to all exchange types.
  */
-type BaseExchangeDefinition = {
+type BaseExchangeDefinition<TName extends string = string> = {
   /**
    * The name of the exchange. Must be unique within the RabbitMQ virtual host.
    */
-  name: string;
+  name: TName;
   /**
    * If true, the exchange survives broker restarts. Durable exchanges are persisted to disk.
    * @default false
@@ -390,7 +389,7 @@ type BaseExchangeDefinition = {
  * });
  * ```
  */
-type FanoutExchangeDefinition = BaseExchangeDefinition & {
+type FanoutExchangeDefinition<TName extends string = string> = BaseExchangeDefinition<TName> & {
   type: "fanout";
 };
 /**
@@ -406,7 +405,7 @@ type FanoutExchangeDefinition = BaseExchangeDefinition & {
  * });
  * ```
  */
-type DirectExchangeDefinition = BaseExchangeDefinition & {
+type DirectExchangeDefinition<TName extends string = string> = BaseExchangeDefinition<TName> & {
   type: "direct";
 };
 /**
@@ -426,7 +425,7 @@ type DirectExchangeDefinition = BaseExchangeDefinition & {
  * // Can be bound with patterns like 'order.*' or 'order.#'
  * ```
  */
-type TopicExchangeDefinition = BaseExchangeDefinition & {
+type TopicExchangeDefinition<TName extends string = string> = BaseExchangeDefinition<TName> & {
   type: "topic";
 };
 /**
@@ -434,7 +433,7 @@ type TopicExchangeDefinition = BaseExchangeDefinition & {
  *
  * Represents any type of AMQP exchange: fanout, direct, or topic.
  */
-type ExchangeDefinition = FanoutExchangeDefinition | DirectExchangeDefinition | TopicExchangeDefinition;
+type ExchangeDefinition<TName extends string = string> = FanoutExchangeDefinition<TName> | DirectExchangeDefinition<TName> | TopicExchangeDefinition<TName>;
 /**
  * Configuration for dead letter exchange (DLX) on a queue.
  *
@@ -457,11 +456,11 @@ type DeadLetterConfig = {
 /**
  * Common properties shared by all queue definitions.
  */
-type BaseQueueDefinition = {
+type BaseQueueDefinition<TName extends string = string> = {
   /**
    * The name of the queue. Must be unique within the RabbitMQ virtual host.
    */
-  name: string;
+  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.
@@ -497,7 +496,7 @@ type BaseQueueDefinition = {
  * 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 = BaseQueueDefinition & {
+type QuorumQueueDefinition<TName extends string = string> = BaseQueueDefinition<TName> & {
   /**
    * Queue type discriminator: quorum queue.
    */
@@ -542,7 +541,7 @@ type QuorumQueueDefinition = BaseQueueDefinition & {
  * 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).
  */
-type ClassicQueueDefinition = BaseQueueDefinition & {
+type ClassicQueueDefinition<TName extends string = string> = BaseQueueDefinition<TName> & {
   /**
    * Queue type discriminator: classic queue.
    */
@@ -575,7 +574,7 @@ type ClassicQueueDefinition = BaseQueueDefinition & {
  *
  * Use `queue.type` as the discriminator to narrow the type.
  */
-type QueueDefinition = QuorumQueueDefinition | ClassicQueueDefinition;
+type QueueDefinition<TName extends string = string> = QuorumQueueDefinition<TName> | ClassicQueueDefinition<TName>;
 /**
  * A queue with automatically generated TTL-backoff retry infrastructure.
  *
@@ -586,20 +585,23 @@ type QueueDefinition = QuorumQueueDefinition | ClassicQueueDefinition;
  * @example
  * ```typescript
  * const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
+ * const exchange = defineExchange('orders', 'topic', { durable: true });
  * 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
  * const contract = defineContract({
- *   exchanges: { dlx },
- *   queues: { orderProcessing: queue }, // Automatically adds wait queue
- *   // ... bindings are automatically generated
+ *   publishers: { orderCreated },
+ *   consumers: { processOrder: defineEventConsumer(orderCreated, extractQueue(queue)) },
  * });
  * ```
  */
-type QueueWithTtlBackoffInfrastructure = {
+type QueueWithTtlBackoffInfrastructure<TName extends string = string> = {
   /**
    * Discriminator to identify this as a queue with TTL-backoff infrastructure.
    * @internal
@@ -608,7 +610,12 @@ type QueueWithTtlBackoffInfrastructure = {
   /**
    * The main queue definition.
    */
-  queue: QueueDefinition;
+  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.
    */
@@ -627,7 +634,7 @@ type QueueWithTtlBackoffInfrastructure = {
  *
  * Can be either a plain queue definition or a queue with TTL-backoff infrastructure.
  */
-type QueueEntry = QueueDefinition | QueueWithTtlBackoffInfrastructure;
+type QueueEntry<TName extends string = string> = QueueDefinition<TName> | QueueWithTtlBackoffInfrastructure<TName>;
 /**
  * Definition of a message with typed payload and optional headers.
  *
@@ -664,9 +671,7 @@ type MessageDefinition<TPayload extends AnySchema = AnySchema, THeaders extends
  * For fanout exchanges, no routing key is needed as all messages are broadcast.
  */
 type QueueBindingDefinition = {
-  /** Discriminator indicating this is a queue-to-exchange binding */
-  type: "queue";
-  /** The queue that will receive messages */
+  /** Discriminator indicating this is a queue-to-exchange binding */type: "queue"; /** The queue that will receive messages */
   queue: QueueDefinition;
   /**
    * Additional AMQP arguments for the binding.
@@ -674,8 +679,7 @@ type QueueBindingDefinition = {
    */
   arguments?: Record<string, unknown>;
 } & ({
-  /** Direct or topic exchange requiring a routing key */
-  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+  /** Direct or topic exchange requiring a routing key */exchange: DirectExchangeDefinition | TopicExchangeDefinition;
   /**
    * The routing key pattern for message routing.
    * For direct exchanges: Must match exactly.
@@ -683,9 +687,7 @@ type QueueBindingDefinition = {
    */
   routingKey: string;
 } | {
-  /** Fanout exchange (no routing key needed) */
-  exchange: FanoutExchangeDefinition;
-  /** Fanout exchanges don't use routing keys */
+  /** Fanout exchange (no routing key needed) */exchange: FanoutExchangeDefinition; /** Fanout exchanges don't use routing keys */
   routingKey?: never;
 });
 /**
@@ -706,26 +708,21 @@ type QueueBindingDefinition = {
  * ```
  */
 type ExchangeBindingDefinition = {
-  /** Discriminator indicating this is an exchange-to-exchange binding */
-  type: "exchange";
-  /** The destination exchange that will receive forwarded messages */
+  /** Discriminator indicating this is an exchange-to-exchange binding */type: "exchange"; /** The destination exchange that will receive forwarded messages */
   destination: ExchangeDefinition;
   /**
    * Additional AMQP arguments for the binding.
    */
   arguments?: Record<string, unknown>;
 } & ({
-  /** Direct or topic source exchange requiring a routing key */
-  source: DirectExchangeDefinition | TopicExchangeDefinition;
+  /** Direct or topic source exchange requiring a routing key */source: DirectExchangeDefinition | TopicExchangeDefinition;
   /**
    * The routing key pattern for message routing.
    * Messages matching this pattern will be forwarded to the destination exchange.
    */
   routingKey: string;
 } | {
-  /** Fanout source exchange (no routing key needed) */
-  source: FanoutExchangeDefinition;
-  /** Fanout exchanges don't use routing keys */
+  /** Fanout source exchange (no routing key needed) */source: FanoutExchangeDefinition; /** Fanout exchanges don't use routing keys */
   routingKey?: never;
 });
 /**
@@ -757,20 +754,16 @@ type BindingDefinition = QueueBindingDefinition | ExchangeBindingDefinition;
  * ```
  */
 type PublisherDefinition<TMessage extends MessageDefinition = MessageDefinition> = {
-  /** The message definition including the payload schema */
-  message: TMessage;
+  /** The message definition including the payload schema */message: TMessage;
 } & ({
-  /** Direct or topic exchange requiring a routing key */
-  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+  /** Direct or topic exchange requiring a routing key */exchange: DirectExchangeDefinition | TopicExchangeDefinition;
   /**
    * The routing key for message routing.
    * Determines which queues will receive the published message.
    */
   routingKey: string;
 } | {
-  /** Fanout exchange (no routing key needed) */
-  exchange: FanoutExchangeDefinition;
-  /** Fanout exchanges don't use routing keys - all bound queues receive the message */
+  /** Fanout exchange (no routing key needed) */exchange: FanoutExchangeDefinition; /** Fanout exchanges don't use routing keys - all bound queues receive the message */
   routingKey?: never;
 });
 /**
@@ -792,9 +785,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: QueueDefinition; /** The message definition including the payload schema */
   message: TMessage;
 };
 /**
@@ -825,6 +816,8 @@ type CommandConsumerConfigBase = {
   consumer: ConsumerDefinition;
   binding: QueueBindingDefinition;
   exchange: ExchangeDefinition;
+  queue: QueueDefinition;
+  deadLetterExchange: ExchangeDefinition | undefined;
   message: MessageDefinition;
   routingKey: string | undefined;
 };
@@ -840,6 +833,9 @@ type EventConsumerResultBase = {
   __brand: "EventConsumerResult";
   consumer: ConsumerDefinition;
   binding: QueueBindingDefinition;
+  exchange: ExchangeDefinition;
+  queue: QueueDefinition;
+  deadLetterExchange: ExchangeDefinition | undefined;
 };
 /**
  * Complete AMQP contract definition (output type).
@@ -926,15 +922,12 @@ type ConsumerEntry = ConsumerDefinition | EventConsumerResultBase | CommandConsu
 /**
  * Contract definition input type with automatic extraction of event/command patterns.
  *
- * This type allows passing event and command configs directly to the publishers
- * and consumers sections. `defineContract` will automatically extract the appropriate
- * definitions and generate bindings.
+ * Users only define publishers and consumers. Exchanges, queues, and bindings are
+ * automatically extracted from these definitions.
  *
  * @example
  * ```typescript
  * const contract = defineContract({
- *   exchanges: { orders: ordersExchange },
- *   queues: { processing: processingQueue },
  *   publishers: {
  *     // EventPublisherConfig → auto-extracted to publisher
  *     orderCreated: defineEventPublisher(ordersExchange, orderMessage, { routingKey: "order.created" }),
@@ -950,7 +943,7 @@ type ConsumerEntry = ConsumerDefinition | EventConsumerResultBase | CommandConsu
  *
  * @see defineContract - Processes this input and returns a ContractDefinition
  */
-type ContractDefinitionInput = Omit<ContractDefinition, "publishers" | "consumers"> & {
+type ContractDefinitionInput = {
   /**
    * Named publisher definitions.
    *
@@ -969,6 +962,130 @@ type ContractDefinitionInput = Omit<ContractDefinition, "publishers" | "consumer
    */
   consumers?: Record<string, ConsumerEntry>;
 };
+/**
+ * Extract the exchange from a publisher entry.
+ * @internal
+ */
+type ExtractPublisherExchange<T extends PublisherEntry> = T extends EventPublisherConfigBase ? T["exchange"] : T extends PublisherDefinition ? T["exchange"] : never;
+/**
+ * Extract the QueueDefinition from a QueueEntry type.
+ * For QueueWithTtlBackoffInfrastructure, returns the inner queue definition.
+ * For QueueDefinition, returns as-is.
+ * For complex intersections, falls back to extracting TName from QueueEntry<TName>.
+ * @internal
+ */
+type ExtractQueueFromEntry<T extends QueueEntry> = T extends QueueWithTtlBackoffInfrastructure<infer TName> ? QueueDefinition<TName> : T extends QueueDefinition<infer TName> ? QueueDefinition<TName> : T extends QueueEntry<infer TName> ? QueueDefinition<TName> : QueueDefinition;
+/**
+ * Extract the dead letter exchange from a QueueEntry type.
+ * Handles both plain queue entries and those with DLX intersection from defineQueue overloads.
+ * @internal
+ */
+type ExtractDlxFromEntry<T extends QueueEntry> = T extends {
+  deadLetter: {
+    exchange: infer E extends ExchangeDefinition;
+  };
+} ? E : T extends QueueWithTtlBackoffInfrastructure ? T["queue"] extends {
+  deadLetter: {
+    exchange: infer E extends ExchangeDefinition;
+  };
+} ? E : undefined : undefined;
+/**
+ * Extract the queue from a consumer entry.
+ * @internal
+ */
+type ExtractConsumerQueue<T extends ConsumerEntry> = T extends EventConsumerResultBase ? T["queue"] : T extends CommandConsumerConfigBase ? T["queue"] : T extends ConsumerDefinition ? T["queue"] : never;
+/**
+ * Extract the exchange from a consumer entry (from binding).
+ * @internal
+ */
+type ExtractConsumerExchange<T extends ConsumerEntry> = T extends EventConsumerResultBase ? T["exchange"] : T extends CommandConsumerConfigBase ? T["exchange"] : never;
+/**
+ * Extract the binding from a consumer entry.
+ * @internal
+ */
+type ExtractConsumerBinding<T extends ConsumerEntry> = T extends EventConsumerResultBase ? T["binding"] : T extends CommandConsumerConfigBase ? T["binding"] : never;
+/**
+ * Check if a consumer entry has a binding.
+ * @internal
+ */
+type HasBinding<T extends ConsumerEntry> = T extends EventConsumerResultBase ? true : T extends CommandConsumerConfigBase ? true : false;
+/**
+ * Extract exchanges from all publishers in a contract.
+ * @internal
+ */
+type ExtractExchangesFromPublishers<TPublishers extends Record<string, PublisherEntry>> = { [K in keyof TPublishers as ExtractPublisherExchange<TPublishers[K]>["name"]]: ExtractPublisherExchange<TPublishers[K]> };
+/**
+ * Extract exchanges from all consumers in a contract.
+ * @internal
+ */
+type ExtractExchangesFromConsumers<TConsumers extends Record<string, ConsumerEntry>> = { [K in keyof TConsumers as ExtractConsumerExchange<TConsumers[K]> extends ExchangeDefinition ? ExtractConsumerExchange<TConsumers[K]>["name"] : never]: ExtractConsumerExchange<TConsumers[K]> extends ExchangeDefinition ? ExtractConsumerExchange<TConsumers[K]> : never };
+/**
+ * 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;
+/**
+ * Extract dead letter exchanges from all consumers in a contract.
+ * @internal
+ */
+type ExtractDeadLetterExchangesFromConsumers<TConsumers extends Record<string, ConsumerEntry>> = { [K in keyof TConsumers as ExtractDeadLetterExchange<TConsumers[K]> extends never ? never : ExtractDeadLetterExchange<TConsumers[K]>["name"]]: ExtractDeadLetterExchange<TConsumers[K]> };
+/**
+ * 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]> };
+/**
+ * Extract bindings from all consumers in a contract.
+ * @internal
+ */
+type ExtractBindingsFromConsumers<TConsumers extends Record<string, ConsumerEntry>> = { [K in keyof TConsumers as HasBinding<TConsumers[K]> extends true ? `${K & string}Binding` : never]: ExtractConsumerBinding<TConsumers[K]> };
+/**
+ * Extract the consumer definition from a consumer entry.
+ * @internal
+ */
+type ExtractConsumerDefinition<T extends ConsumerEntry> = T extends EventConsumerResultBase ? T["consumer"] : T extends CommandConsumerConfigBase ? T["consumer"] : T extends ConsumerDefinition ? T : never;
+/**
+ * Extract consumer definitions from all consumers in a contract.
+ * @internal
+ */
+type ExtractConsumerDefinitions<TConsumers extends Record<string, ConsumerEntry>> = { [K in keyof TConsumers]: ExtractConsumerDefinition<TConsumers[K]> };
+/**
+ * Extract the publisher definition from a publisher entry.
+ * @internal
+ */
+type ExtractPublisherDefinition<T extends PublisherEntry> = T extends EventPublisherConfigBase ? PublisherDefinition<T["message"]> & (T["exchange"] extends FanoutExchangeDefinition ? {
+  exchange: T["exchange"];
+  routingKey?: never;
+} : {
+  exchange: T["exchange"];
+  routingKey: T["routingKey"] & string;
+}) : T extends PublisherDefinition ? T : never;
+/**
+ * Extract publisher definitions from all publishers in a contract.
+ * @internal
+ */
+type ExtractPublisherDefinitions<TPublishers extends Record<string, PublisherEntry>> = { [K in keyof TPublishers]: ExtractPublisherDefinition<TPublishers[K]> };
+/**
+ * Contract output type with all resources extracted and properly typed.
+ *
+ * This type represents the fully expanded contract with:
+ * - exchanges: Extracted from publishers and consumer bindings
+ * - queues: Extracted from consumers
+ * - bindings: Extracted from event/command consumers
+ * - publishers: Normalized publisher definitions
+ * - 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"]> : {});
+  queues: TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractQueuesFromConsumers<TContract["consumers"]> : {};
+  bindings: TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractBindingsFromConsumers<TContract["consumers"]> : {};
+  publishers: TContract["publishers"] extends Record<string, PublisherEntry> ? ExtractPublisherDefinitions<TContract["publishers"]> : {};
+  consumers: TContract["consumers"] extends Record<string, ConsumerEntry> ? ExtractConsumerDefinitions<TContract["consumers"]> : {};
+};
 /**
  * Extract publisher names from a contract.
  *
@@ -1025,7 +1142,7 @@ type InferConsumerNames<TContract extends ContractDefinition> = TContract["consu
  * });
  * ```
  */
-declare function defineExchange(name: string, type: "fanout", options?: Omit<BaseExchangeDefinition, "name" | "type">): FanoutExchangeDefinition;
+declare function defineExchange<TName extends string>(name: TName, type: "fanout", options?: Omit<BaseExchangeDefinition, "name" | "type">): FanoutExchangeDefinition<TName>;
 /**
  * Define a direct exchange.
  *
@@ -1048,7 +1165,7 @@ declare function defineExchange(name: string, type: "fanout", options?: Omit<Bas
  * });
  * ```
  */
-declare function defineExchange(name: string, type: "direct", options?: Omit<BaseExchangeDefinition, "name" | "type">): DirectExchangeDefinition;
+declare function defineExchange<TName extends string>(name: TName, type: "direct", options?: Omit<BaseExchangeDefinition, "name" | "type">): DirectExchangeDefinition<TName>;
 /**
  * Define a topic exchange.
  *
@@ -1072,7 +1189,7 @@ declare function defineExchange(name: string, type: "direct", options?: Omit<Bas
  * });
  * ```
  */
-declare function defineExchange(name: string, type: "topic", options?: Omit<BaseExchangeDefinition, "name" | "type">): TopicExchangeDefinition;
+declare function defineExchange<TName extends string>(name: TName, type: "topic", options?: Omit<BaseExchangeDefinition, "name" | "type">): TopicExchangeDefinition<TName>;
 //#endregion
 //#region src/builder/message.d.ts
 /**
@@ -1199,7 +1316,7 @@ declare function isQueueWithTtlBackoffInfrastructure(entry: QueueEntry): entry i
  * @see isQueueWithTtlBackoffInfrastructure - Type guard to check if extraction is needed
  * @see defineTtlBackoffQueue - Creates queues with TTL-backoff infrastructure
  */
-declare function extractQueue(entry: QueueEntry): QueueDefinition;
+declare function extractQueue<T extends QueueEntry>(entry: T): ExtractQueueFromEntry<T>;
 /**
  * Define an AMQP queue.
  *
@@ -1262,7 +1379,16 @@ declare function extractQueue(entry: QueueEntry): QueueDefinition;
  * // orderQueue is QueueWithTtlBackoffInfrastructure, pass directly to defineContract
  * ```
  */
-declare function defineQueue(name: string, options?: DefineQueueOptions): QueueDefinition | QueueWithTtlBackoffInfrastructure;
+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.
  *
@@ -1321,17 +1447,17 @@ type DefineQuorumQueueOptions = {
  *   deliveryLimit: 3, // Retry up to 3 times
  * });
  *
+ * // Use in a contract — exchanges, queues, and bindings are auto-extracted
  * const contract = defineContract({
- *   exchanges: { dlx },
- *   queues: { orderProcessing: orderQueue },
- *   // ...
+ *   publishers: { ... },
+ *   consumers: { processOrder: defineEventConsumer(event, orderQueue) },
  * });
  * ```
  *
  * @see defineQueue - For full queue configuration options
  * @see defineTtlBackoffQueue - For queues with exponential backoff retry
  */
-declare function defineQuorumQueue(name: string, options: DefineQuorumQueueOptions): QuorumQueueDefinition;
+declare function defineQuorumQueue<TName extends string>(name: TName, options: DefineQuorumQueueOptions): QuorumQueueDefinition<TName>;
 /**
  * Options for creating a queue with TTL-backoff retry.
  *
@@ -1417,10 +1543,10 @@ type DefineTtlBackoffQueueOptions = {
  *   maxDelayMs: 30000,     // Cap at 30s
  * });
  *
+ * // Use in a contract — wait queue, bindings, and DLX are auto-extracted
  * const contract = defineContract({
- *   exchanges: { dlx },
- *   queues: { orderProcessing: orderQueue }, // Wait queue auto-added
- *   // ... bindings auto-generated
+ *   publishers: { ... },
+ *   consumers: { processOrder: defineEventConsumer(event, extractQueue(orderQueue)) },
  * });
  *
  * // To access the underlying queue definition (e.g., for the queue name):
@@ -1432,7 +1558,7 @@ type DefineTtlBackoffQueueOptions = {
  * @see defineQuorumQueue - For queues with quorum-native retry (simpler, immediate retries)
  * @see extractQueue - To access the underlying queue definition
  */
-declare function defineTtlBackoffQueue(name: string, options: DefineTtlBackoffQueueOptions): QueueWithTtlBackoffInfrastructure;
+declare function defineTtlBackoffQueue<TName extends string>(name: TName, options: DefineTtlBackoffQueueOptions): QueueWithTtlBackoffInfrastructure<TName>;
 //#endregion
 //#region src/builder/binding.d.ts
 /**
@@ -1664,6 +1790,37 @@ declare function definePublisher<TMessage extends MessageDefinition>(exchange: D
 }>;
 //#endregion
 //#region src/builder/consumer.d.ts
+/**
+ * Extract the ConsumerDefinition from any ConsumerEntry type.
+ *
+ * Handles the following entry types:
+ * - ConsumerDefinition: returned as-is
+ * - EventConsumerResult: returns the nested `.consumer` property
+ * - CommandConsumerConfig: returns the nested `.consumer` property
+ *
+ * Use this function when you need to access the underlying ConsumerDefinition
+ * from a consumer entry that may have been created with defineEventConsumer
+ * or defineCommandConsumer.
+ *
+ * @param entry - The consumer entry to extract from
+ * @returns The underlying ConsumerDefinition
+ *
+ * @example
+ * ```typescript
+ * // Works with plain ConsumerDefinition
+ * const consumer1 = defineConsumer(queue, message);
+ * extractConsumer(consumer1).queue.name; // "my-queue"
+ *
+ * // Works with EventConsumerResult
+ * const consumer2 = defineEventConsumer(eventPublisher, queue);
+ * extractConsumer(consumer2).queue.name; // "my-queue"
+ *
+ * // Works with CommandConsumerConfig
+ * const consumer3 = defineCommandConsumer(queue, exchange, message, { routingKey: "cmd" });
+ * extractConsumer(consumer3).queue.name; // "my-queue"
+ * ```
+ */
+declare function extractConsumer(entry: ConsumerEntry): ConsumerDefinition;
 /**
  * Define a message consumer.
  *
@@ -1725,29 +1882,21 @@ declare function definePublisher<TMessage extends MessageDefinition>(exchange: D
 declare function defineConsumer<TMessage extends MessageDefinition>(queue: QueueEntry, message: TMessage, options?: Omit<ConsumerDefinition<TMessage>, "queue" | "message">): ConsumerDefinition<TMessage>;
 //#endregion
 //#region src/builder/contract.d.ts
-/**
- * Type utility to produce the output contract type from the input.
- * The output has the same structure but with all entries normalized to
- * their base definition types (PublisherDefinition, ConsumerDefinition).
- */
-type ContractOutput<TContract extends ContractDefinitionInput> = TContract;
 /**
  * Define an AMQP contract.
  *
  * A contract is the central definition of your AMQP messaging topology. It brings together
- * all exchanges, queues, bindings, publishers, and consumers in a single, type-safe definition.
+ * publishers and consumers in a single, type-safe definition. Exchanges, queues, and bindings
+ * are automatically extracted from publishers and consumers.
  *
  * The contract is used by both clients (for publishing) and workers (for consuming) to ensure
  * type safety throughout your messaging infrastructure. TypeScript will infer all message types
  * and publisher/consumer names from the contract.
  *
- * @param definition - The contract definition containing all AMQP resources
- * @param definition.exchanges - Named exchange definitions
- * @param definition.queues - Named queue definitions
- * @param definition.bindings - Named binding definitions (queue-to-exchange or exchange-to-exchange)
+ * @param definition - The contract definition containing publishers and consumers
  * @param definition.publishers - Named publisher definitions for sending messages
  * @param definition.consumers - Named consumer definitions for receiving messages
- * @returns The same contract definition with full type inference
+ * @returns The contract definition with fully inferred exchanges, queues, bindings, publishers, and consumers
  *
  * @example
  * ```typescript
@@ -1755,16 +1904,20 @@ type ContractOutput<TContract extends ContractDefinitionInput> = TContract;
  *   defineContract,
  *   defineExchange,
  *   defineQueue,
- *   defineQueueBinding,
- *   definePublisher,
- *   defineConsumer,
+ *   defineEventPublisher,
+ *   defineEventConsumer,
  *   defineMessage,
  * } from '@amqp-contract/contract';
  * import { z } from 'zod';
  *
  * // Define resources
  * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
- * const orderQueue = defineQueue('order-processing', { durable: true });
+ * const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
+ * const orderQueue = defineQueue('order-processing', {
+ *   deadLetter: { exchange: dlx },
+ *   retry: { mode: 'quorum-native' },
+ *   deliveryLimit: 3,
+ * });
  * const orderMessage = defineMessage(
  *   z.object({
  *     orderId: z.string(),
@@ -1772,32 +1925,27 @@ type ContractOutput<TContract extends ContractDefinitionInput> = TContract;
  *   })
  * );
  *
- * // Compose contract
+ * // Define event publisher
+ * const orderCreatedEvent = defineEventPublisher(ordersExchange, orderMessage, {
+ *   routingKey: 'order.created',
+ * });
+ *
+ * // Compose contract - exchanges, queues, bindings are auto-extracted
  * export const contract = defineContract({
- *   exchanges: {
- *     orders: ordersExchange,
- *   },
- *   queues: {
- *     orderProcessing: orderQueue,
- *   },
- *   bindings: {
- *     orderBinding: defineQueueBinding(orderQueue, ordersExchange, {
- *       routingKey: 'order.created',
- *     }),
- *   },
  *   publishers: {
- *     orderCreated: definePublisher(ordersExchange, orderMessage, {
- *       routingKey: 'order.created',
- *     }),
+ *     orderCreated: orderCreatedEvent,
  *   },
  *   consumers: {
- *     processOrder: defineConsumer(orderQueue, orderMessage),
+ *     processOrder: defineEventConsumer(orderCreatedEvent, orderQueue),
  *   },
  * });
  *
  * // TypeScript now knows:
+ * // - contract.exchanges.orders, contract.exchanges['orders-dlx']
+ * // - contract.queues['order-processing']
+ * // - contract.bindings.processOrderBinding
  * // - client.publish('orderCreated', { orderId: string, amount: number })
- * // - handler: async (message: { orderId: string, amount: number }) => void
+ * // - handler: (message: { orderId: string, amount: number }) => Future<Result<void, HandlerError>>
  * ```
  */
 declare function defineContract<TContract extends ContractDefinitionInput>(definition: TContract): ContractOutput<TContract>;
@@ -1851,7 +1999,7 @@ type BindingPattern<S extends string> = S extends "" ? never : S;
  * Handles backtracking to match # with zero or more segments
  * @internal
  */
-type MatchesAfterHash<Key extends string, PatternRest$1 extends string> = MatchesPattern<Key, PatternRest$1> extends true ? true : Key extends `${string}.${infer KeyRest}` ? MatchesAfterHash<KeyRest, PatternRest$1> : false;
+type MatchesAfterHash<Key extends string, PatternRest extends string> = MatchesPattern<Key, PatternRest> extends true ? true : Key extends `${string}.${infer KeyRest}` ? MatchesAfterHash<KeyRest, PatternRest> : false;
 /**
  * Check if a routing key matches a binding pattern
  * Implements AMQP topic exchange pattern matching:
@@ -1893,15 +2041,10 @@ type MatchingRoutingKey<Pattern extends string, Key extends string> = RoutingKey
  * @template TRoutingKey - The routing key type (undefined for fanout)
  */
 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 */
-  exchange: TExchange;
-  /** The message definition */
-  message: TMessage;
-  /** The routing key for direct/topic exchanges */
-  routingKey: TRoutingKey;
-  /** Additional AMQP arguments */
+  /** Discriminator to identify this as an event publisher config */__brand: "EventPublisherConfig"; /** The exchange to publish to */
+  exchange: TExchange; /** The message definition */
+  message: TMessage; /** The routing key for direct/topic exchanges */
+  routingKey: TRoutingKey; /** Additional AMQP arguments */
   arguments?: Record<string, unknown>;
 };
 /**
@@ -1913,13 +2056,13 @@ type EventPublisherConfig<TMessage extends MessageDefinition, TExchange extends
  *
  * @template TMessage - The message definition
  */
-type EventConsumerResult<TMessage extends MessageDefinition> = {
-  /** 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;
+type EventConsumerResult<TMessage extends MessageDefinition, TExchange extends ExchangeDefinition = ExchangeDefinition, TQueue extends QueueDefinition = QueueDefinition, TDlxExchange 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 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;
 };
 /**
  * Define an event publisher for broadcasting messages via fanout exchange.
@@ -1949,7 +2092,7 @@ type EventConsumerResult<TMessage extends MessageDefinition> = {
  *   defineEventConsumer(logEvent, alertsQueue);
  * ```
  */
-declare function defineEventPublisher<TMessage extends MessageDefinition>(exchange: FanoutExchangeDefinition, message: TMessage): EventPublisherConfig<TMessage, FanoutExchangeDefinition, undefined>;
+declare function defineEventPublisher<TMessage extends MessageDefinition, TExchange extends FanoutExchangeDefinition>(exchange: TExchange, message: TMessage): EventPublisherConfig<TMessage, TExchange, undefined>;
 /**
  * Define an event publisher for broadcasting messages via direct exchange.
  *
@@ -1973,10 +2116,10 @@ declare function defineEventPublisher<TMessage extends MessageDefinition>(exchan
  * });
  * ```
  */
-declare function defineEventPublisher<TMessage extends MessageDefinition, TRoutingKey extends string>(exchange: DirectExchangeDefinition, message: TMessage, options: {
+declare function defineEventPublisher<TMessage extends MessageDefinition, TRoutingKey extends string, TExchange extends DirectExchangeDefinition>(exchange: TExchange, message: TMessage, options: {
   routingKey: RoutingKey<TRoutingKey>;
   arguments?: Record<string, unknown>;
-}): EventPublisherConfig<TMessage, DirectExchangeDefinition, TRoutingKey>;
+}): EventPublisherConfig<TMessage, TExchange, TRoutingKey>;
 /**
  * Define an event publisher for broadcasting messages via topic exchange.
  *
@@ -2011,10 +2154,10 @@ declare function defineEventPublisher<TMessage extends MessageDefinition, TRouti
  * );
  * ```
  */
-declare function defineEventPublisher<TMessage extends MessageDefinition, TRoutingKey extends string>(exchange: TopicExchangeDefinition, message: TMessage, options: {
+declare function defineEventPublisher<TMessage extends MessageDefinition, TRoutingKey extends string, TExchange extends TopicExchangeDefinition>(exchange: TExchange, message: TMessage, options: {
   routingKey: RoutingKey<TRoutingKey>;
   arguments?: Record<string, unknown>;
-}): EventPublisherConfig<TMessage, TopicExchangeDefinition, TRoutingKey>;
+}): EventPublisherConfig<TMessage, TExchange, TRoutingKey>;
 /**
  * Create a consumer that subscribes to an event from a fanout exchange.
  *
@@ -2029,9 +2172,9 @@ declare function defineEventPublisher<TMessage extends MessageDefinition, TRouti
  * const { consumer, binding } = defineEventConsumer(logEvent, logsQueue);
  * ```
  */
-declare function defineEventConsumer<TMessage extends MessageDefinition>(eventPublisher: EventPublisherConfig<TMessage, FanoutExchangeDefinition, undefined>, queue: QueueEntry, options?: {
+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>;
+}): EventConsumerResult<TMessage, TExchange, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
 /**
  * Create a consumer that subscribes to an event from a direct exchange.
  *
@@ -2040,9 +2183,9 @@ declare function defineEventConsumer<TMessage extends MessageDefinition>(eventPu
  * @param options - Optional binding configuration
  * @returns An object with the consumer definition and binding
  */
-declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutingKey extends string>(eventPublisher: EventPublisherConfig<TMessage, DirectExchangeDefinition, TRoutingKey>, queue: QueueEntry, options?: {
+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>;
+}): EventConsumerResult<TMessage, TExchange, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
 /**
  * Create a consumer that subscribes to an event from a topic exchange.
  *
@@ -2070,10 +2213,10 @@ declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutin
  * });
  * ```
  */
-declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutingKey extends string, TConsumerRoutingKey extends string = TRoutingKey>(eventPublisher: EventPublisherConfig<TMessage, TopicExchangeDefinition, TRoutingKey>, queue: QueueEntry, options?: {
+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>;
+}): EventConsumerResult<TMessage, TExchange, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
 /**
  * Type guard to check if a value is an EventPublisherConfig.
  *
@@ -2100,18 +2243,14 @@ declare function isEventConsumerResult(value: unknown): value is EventConsumerRe
  * @template TExchange - The exchange definition
  * @template TRoutingKey - The routing key type (undefined for fanout)
  */
-type CommandConsumerConfig<TMessage extends MessageDefinition, TExchange extends ExchangeDefinition, TRoutingKey extends string | undefined = undefined> = {
-  /** 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 message definition */
-  message: TMessage;
-  /** The routing key pattern for the binding */
+type CommandConsumerConfig<TMessage extends MessageDefinition, TExchange extends ExchangeDefinition, TRoutingKey extends string | undefined = undefined, TQueue extends QueueDefinition = QueueDefinition, TDlxExchange extends ExchangeDefinition | undefined = ExchangeDefinition | undefined> = {
+  /** 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 */
+  message: TMessage; /** The routing key pattern for the binding */
   routingKey: TRoutingKey;
 };
 /**
@@ -2137,7 +2276,7 @@ type CommandConsumerConfig<TMessage extends MessageDefinition, TExchange extends
  * const sendTask = defineCommandPublisher(executeTask);
  * ```
  */
-declare function defineCommandConsumer<TMessage extends MessageDefinition>(queue: QueueEntry, exchange: FanoutExchangeDefinition, message: TMessage): CommandConsumerConfig<TMessage, FanoutExchangeDefinition, undefined>;
+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>>;
 /**
  * Define a command consumer for receiving commands via direct exchange.
  *
@@ -2164,10 +2303,10 @@ declare function defineCommandConsumer<TMessage extends MessageDefinition>(queue
  * const sendTask = defineCommandPublisher(executeTask);
  * ```
  */
-declare function defineCommandConsumer<TMessage extends MessageDefinition, TRoutingKey extends string>(queue: QueueEntry, exchange: DirectExchangeDefinition, message: TMessage, options: {
+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, DirectExchangeDefinition, TRoutingKey>;
+}): CommandConsumerConfig<TMessage, TExchange, TRoutingKey, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
 /**
  * Define a command consumer for receiving commands via topic exchange.
  *
@@ -2201,10 +2340,10 @@ declare function defineCommandConsumer<TMessage extends MessageDefinition, TRout
  * });
  * ```
  */
-declare function defineCommandConsumer<TMessage extends MessageDefinition, TRoutingKey extends string>(queue: QueueEntry, exchange: TopicExchangeDefinition, message: TMessage, options: {
+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, TopicExchangeDefinition, TRoutingKey>;
+}): CommandConsumerConfig<TMessage, TExchange, TRoutingKey, ExtractQueueFromEntry<TQueueEntry>, ExtractDlxFromEntry<TQueueEntry>>;
 /**
  * Create a publisher that sends commands to a fanout exchange consumer.
  *
@@ -2323,28 +2462,20 @@ type TtlBackoffRetryInfrastructure = {
  *   },
  * });
  *
- * // Generate TTL-backoff infrastructure
- * const retryInfra = defineTtlBackoffRetryInfrastructure(orderQueue);
- *
- * // Spread into contract
+ * // Infrastructure is auto-extracted when using defineContract:
  * const contract = defineContract({
- *   exchanges: { dlx },
- *   queues: {
- *     orderProcessing: orderQueue,
- *     orderProcessingWait: retryInfra.waitQueue,
- *   },
- *   bindings: {
- *     ...// your other bindings
- *     orderWaitBinding: retryInfra.waitQueueBinding,
- *     orderRetryBinding: retryInfra.mainQueueRetryBinding,
- *   },
- *   // ... publishers and consumers
+ *   publishers: { ... },
+ *   consumers: { processOrder: defineEventConsumer(event, extractQueue(orderQueue)) },
  * });
+ * // contract.queues includes the wait queue, contract.bindings includes retry bindings
+ *
+ * // Or generate manually for advanced use cases:
+ * const retryInfra = defineTtlBackoffRetryInfrastructure(orderQueue);
  * ```
  */
 declare function defineTtlBackoffRetryInfrastructure(queueEntry: QueueEntry, options?: {
   waitQueueDurable?: boolean;
 }): TtlBackoffRetryInfrastructure;
 //#endregion
-export { type AnySchema, type BaseExchangeDefinition, type BindingDefinition, type BindingPattern, type ClassicQueueDefinition, type ClassicQueueOptions, type CommandConsumerConfig, type CommandConsumerConfigBase, type CompressionAlgorithm, type ConsumerDefinition, type ConsumerEntry, type ContractDefinition, type ContractDefinitionInput, 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, extractQueue, isCommandConsumerConfig, isEventConsumerResult, isEventPublisherConfig, isQueueWithTtlBackoffInfrastructure };
+export { type AnySchema, type BaseExchangeDefinition, type BindingDefinition, type BindingPattern, 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, isCommandConsumerConfig, isEventConsumerResult, isEventPublisherConfig, isQueueWithTtlBackoffInfrastructure };
 //# sourceMappingURL=index.d.cts.map