@amqp-contract/contract 0.4.0 → 0.6.0

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/builder.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/builder.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.d.mts

@@ -103,6 +103,25 @@ type TopicExchangeDefinition = BaseExchangeDefinition & {
  * Represents any type of AMQP exchange: fanout, direct, or topic.
  */
 type ExchangeDefinition = FanoutExchangeDefinition | DirectExchangeDefinition | TopicExchangeDefinition;
+/**
+ * Configuration for dead letter exchange (DLX) on a queue.
+ *
+ * When a message in a queue is rejected, expires, or exceeds the queue length limit,
+ * it can be automatically forwarded to a dead letter exchange for further processing
+ * or storage.
+ */
+type DeadLetterConfig = {
+  /**
+   * The exchange to send dead-lettered messages to.
+   * This exchange must be declared in the contract.
+   */
+  exchange: ExchangeDefinition;
+  /**
+   * Optional routing key to use when forwarding messages to the dead letter exchange.
+   * If not specified, the original message routing key is used.
+   */
+  routingKey?: string;
+};
 /**
  * Definition of an AMQP queue.
  *
@@ -130,6 +149,25 @@ type QueueDefinition = {
    * @default false
    */
   autoDelete?: boolean;
+  /**
+   * Dead letter configuration for handling failed or rejected messages.
+   *
+   * When configured, messages that are rejected, expire, or exceed queue limits
+   * will be automatically forwarded to the specified dead letter exchange.
+   *
+   * @example
+   * ```typescript
+   * const dlx = defineExchange('orders-dlx', 'topic', { durable: true });
+   * const queue = defineQueue('order-processing', {
+   *   durable: true,
+   *   deadLetter: {
+   *     exchange: dlx,
+   *     routingKey: 'order.failed'
+   *   }
+   * });
+   * ```
+   */
+  deadLetter?: DeadLetterConfig;
   /**
    * Additional AMQP arguments for advanced configuration.
    *
@@ -138,15 +176,16 @@ type QueueDefinition = {
    * - `x-expires`: Queue expiration time in milliseconds
    * - `x-max-length`: Maximum number of messages in the queue
    * - `x-max-length-bytes`: Maximum size of the queue in bytes
-   * - `x-dead-letter-exchange`: Exchange for dead-lettered messages
-   * - `x-dead-letter-routing-key`: Routing key for dead-lettered messages
    * - `x-max-priority`: Maximum priority level for priority queues
    *
+   * Note: When using the `deadLetter` property, the `x-dead-letter-exchange` and
+   * `x-dead-letter-routing-key` arguments are automatically set and should not be
+   * specified in this arguments object.
+   *
    * @example
    * ```typescript
    * {
    *   'x-message-ttl': 86400000, // 24 hours
-   *   'x-dead-letter-exchange': 'dlx',
    *   'x-max-priority': 10
    * }
    * ```
@@ -494,16 +533,27 @@ declare function defineExchange(name: string, type: "topic", options?: Omit<Base
  * @param options.durable - If true, the queue survives broker restarts (default: false)
  * @param options.exclusive - If true, the queue can only be used by the declaring connection (default: false)
  * @param options.autoDelete - If true, the queue is deleted when the last consumer unsubscribes (default: false)
- * @param options.arguments - Additional AMQP arguments (e.g., x-message-ttl, x-dead-letter-exchange)
+ * @param options.deadLetter - Dead letter configuration for handling failed messages
+ * @param options.arguments - Additional AMQP arguments (e.g., x-message-ttl, x-max-priority)
  * @returns A queue definition
  *
  * @example
  * ```typescript
- * const orderProcessingQueue = defineQueue('order-processing', {
+ * // Basic queue
+ * const orderQueue = defineQueue('order-processing', {
  *   durable: true,
+ * });
+ *
+ * // Queue with dead letter exchange
+ * const dlx = defineExchange('orders-dlx', 'topic', { durable: true });
+ * const orderQueueWithDLX = defineQueue('order-processing', {
+ *   durable: true,
+ *   deadLetter: {
+ *     exchange: dlx,
+ *     routingKey: 'order.failed'
+ *   },
  *   arguments: {
  *     'x-message-ttl': 86400000, // 24 hours
- *     'x-dead-letter-exchange': 'orders-dlx'
  *   }
  * });
  * ```
@@ -856,7 +906,7 @@ declare function defineConsumer<TMessage extends MessageDefinition>(queue: Queue
  */
 declare function defineContract<TContract extends ContractDefinition>(definition: TContract): TContract;
 /**
- * Publisher-first builder result.
+ * Publisher-first builder result for fanout and direct exchanges.
  *
  * This type represents a publisher and provides a method to create
  * a consumer that uses the same message schema with a binding to the exchange.
@@ -883,6 +933,108 @@ type PublisherFirstResult<TMessage extends MessageDefinition, TPublisher extends
     binding: QueueBindingDefinition;
   };
 };
+/**
+ * Type-safe routing key that validates basic format.
+ *
+ * Validates that a routing key follows basic AMQP routing key rules:
+ * - Must not contain wildcards (* or #)
+ * - Must not be empty
+ * - Should contain alphanumeric characters, dots, hyphens, and underscores
+ *
+ * Note: Full character-by-character validation is not performed to avoid TypeScript
+ * recursion depth limits. Runtime validation is still recommended.
+ *
+ * @public
+ * @template S - The routing key string to validate
+ * @example
+ * ```typescript
+ * type Valid = RoutingKey<"order.created">; // "order.created"
+ * type Invalid = RoutingKey<"order.*">; // never (contains wildcard)
+ * type Invalid2 = RoutingKey<"">; // never (empty string)
+ * ```
+ */
+type RoutingKey<S extends string> = S extends "" ? never : S extends `${string}*${string}` | `${string}#${string}` ? never : S;
+/**
+ * Type-safe binding pattern that validates basic format and wildcards.
+ *
+ * Validates that a binding pattern follows basic AMQP binding pattern rules:
+ * - Can contain wildcards (* for one word, # for zero or more words)
+ * - Must not be empty
+ * - Should contain alphanumeric characters, dots, hyphens, underscores, and wildcards
+ *
+ * Note: Full character-by-character validation is not performed to avoid TypeScript
+ * recursion depth limits. Runtime validation is still recommended.
+ *
+ * @public
+ * @template S - The binding pattern string to validate
+ * @example
+ * ```typescript
+ * type ValidPattern = BindingPattern<"order.*">; // "order.*"
+ * type ValidHash = BindingPattern<"order.#">; // "order.#"
+ * type ValidConcrete = BindingPattern<"order.created">; // "order.created"
+ * type Invalid = BindingPattern<"">; // never (empty string)
+ * ```
+ */
+type BindingPattern<S extends string> = S extends "" ? never : S;
+/**
+ * Helper type for pattern matching with # in the middle
+ * 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;
+/**
+ * Check if a routing key matches a binding pattern
+ * Implements AMQP topic exchange pattern matching:
+ * - * matches exactly one word
+ * - # matches zero or more words
+ * @internal
+ */
+type MatchesPattern<Key extends string, Pattern extends string> = Pattern extends `${infer PatternPart}.${infer PatternRest}` ? PatternPart extends "#" ? MatchesAfterHash<Key, PatternRest> : Key extends `${infer KeyPart}.${infer KeyRest}` ? PatternPart extends "*" ? MatchesPattern<KeyRest, PatternRest> : PatternPart extends KeyPart ? MatchesPattern<KeyRest, PatternRest> : false : false : Pattern extends "#" ? true : Pattern extends "*" ? Key extends `${string}.${string}` ? false : true : Pattern extends Key ? true : false;
+/**
+ * Validate that a routing key matches a binding pattern.
+ *
+ * This is a utility type provided for users who want compile-time validation
+ * that a routing key matches a specific pattern. It's not enforced internally
+ * in the API to avoid TypeScript recursion depth issues with complex routing keys.
+ *
+ * Returns the routing key if it's valid and matches the pattern, `never` otherwise.
+ *
+ * @example
+ * ```typescript
+ * type ValidKey = MatchingRoutingKey<"order.*", "order.created">; // "order.created"
+ * type InvalidKey = MatchingRoutingKey<"order.*", "user.created">; // never
+ * ```
+ *
+ * @template Pattern - The binding pattern (can contain * and # wildcards)
+ * @template Key - The routing key to validate
+ */
+type MatchingRoutingKey<Pattern extends string, Key extends string> = RoutingKey<Key> extends never ? never : BindingPattern<Pattern> extends never ? never : MatchesPattern<Key, Pattern> extends true ? Key : never;
+/**
+ * Publisher-first builder result for topic exchanges.
+ *
+ * This type represents a publisher with a concrete routing key and provides a method
+ * to create consumers that can use routing key patterns matching the publisher's key.
+ *
+ * @template TMessage - The message definition
+ * @template TPublisher - The publisher definition
+ * @template TRoutingKey - The literal routing key type from the publisher (for documentation purposes)
+ */
+type PublisherFirstResultWithRoutingKey<TMessage extends MessageDefinition, TPublisher extends PublisherDefinition<TMessage>, TRoutingKey extends string> = {
+  /** The publisher definition */
+  publisher: TPublisher;
+  /**
+   * Create a consumer that receives messages from this publisher.
+   * For topic exchanges, the routing key pattern can be specified for the binding.
+   *
+   * @param queue - The queue that will consume the messages
+   * @param routingKey - Optional routing key pattern for the binding (defaults to publisher's routing key)
+   * @returns An object with the consumer definition and binding
+   */
+  createConsumer: <TConsumerRoutingKey extends string = TRoutingKey>(queue: QueueDefinition, routingKey?: BindingPattern<TConsumerRoutingKey>) => {
+    consumer: ConsumerDefinition<TMessage>;
+    binding: QueueBindingDefinition;
+  };
+};
 /**
  * Define a publisher-first relationship for event-oriented messaging.
  *
@@ -911,15 +1063,15 @@ type PublisherFirstResult<TMessage extends MessageDefinition, TPublisher extends
  * );
  *
  * // Create publisher-first relationship (event pattern)
- * const logEvent = definePublisherFirst(logsExchange, logMessage);
+ * const { publisher: publishLog, createConsumer: createLogConsumer } = definePublisherFirst(logsExchange, logMessage);
  *
  * // Multiple queues can consume the same event
  * const logsQueue1 = defineQueue('logs-queue-1', { durable: true });
  * const logsQueue2 = defineQueue('logs-queue-2', { durable: true });
  *
  * // Use in contract
- * const { consumer: consumer1, binding: binding1 } = logEvent.createConsumer(logsQueue1);
- * const { consumer: consumer2, binding: binding2 } = logEvent.createConsumer(logsQueue2);
+ * const { consumer: consumer1, binding: binding1 } = createLogConsumer(logsQueue1);
+ * const { consumer: consumer2, binding: binding2 } = createLogConsumer(logsQueue2);
  *
  * const contract = defineContract({
  *   exchanges: { logs: logsExchange },
@@ -928,7 +1080,7 @@ type PublisherFirstResult<TMessage extends MessageDefinition, TPublisher extends
  *     logBinding1: binding1,
  *     logBinding2: binding2,
  *   },
- *   publishers: { publishLog: logEvent.publisher },
+ *   publishers: { publishLog },
  *   consumers: {
  *     consumeLog1: consumer1,
  *     consumeLog2: consumer2,
@@ -942,7 +1094,7 @@ declare function definePublisherFirst<TMessage extends MessageDefinition>(exchan
   exchange: FanoutExchangeDefinition;
 }>>;
 /**
- * Define a publisher-first relationship for event-oriented messaging.
+ * Define a publisher-first relationship for event-oriented messaging with direct exchange.
  *
  * This builder enforces consistency by:
  * 1. Ensuring the publisher and consumer use the same message schema
@@ -951,7 +1103,7 @@ declare function definePublisherFirst<TMessage extends MessageDefinition>(exchan
  * Use this pattern for events where publishers don't need to know about queues.
  * Multiple consumers can be created for different queues, all using the same message schema.
  *
- * @param exchange - The exchange to publish to (direct or topic type)
+ * @param exchange - The exchange to publish to (direct type)
  * @param message - The message definition (schema and metadata)
  * @param options - Binding configuration (routingKey is required)
  * @param options.routingKey - The routing key for message routing
@@ -961,6 +1113,61 @@ declare function definePublisherFirst<TMessage extends MessageDefinition>(exchan
  * ```typescript
  * import { z } from 'zod';
  *
+ * const tasksExchange = defineExchange('tasks', 'direct', { durable: true });
+ * const taskMessage = defineMessage(
+ *   z.object({
+ *     taskId: z.string(),
+ *     payload: z.record(z.unknown()),
+ *   })
+ * );
+ *
+ * // Create publisher-first relationship with routing key
+ * const { publisher: executeTaskPublisher, createConsumer: createTaskConsumer } = definePublisherFirst(
+ *   tasksExchange,
+ *   taskMessage,
+ *   { routingKey: 'task.execute' }
+ * );
+ *
+ * // Use in contract - routing key is consistent across publisher and bindings
+ * const taskQueue = defineQueue('task-queue', { durable: true });
+ * const { consumer, binding } = createTaskConsumer(taskQueue);
+ *
+ * const contract = defineContract({
+ *   exchanges: { tasks: tasksExchange },
+ *   queues: { taskQueue },
+ *   bindings: { taskBinding: binding },
+ *   publishers: { executeTask: executeTaskPublisher },
+ *   consumers: { processTask: consumer },
+ * });
+ * ```
+ */
+declare function definePublisherFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(exchange: DirectExchangeDefinition, message: TMessage, options: {
+  routingKey: RoutingKey<TRoutingKey>;
+  arguments?: Record<string, unknown>;
+}): PublisherFirstResult<TMessage, Extract<PublisherDefinition<TMessage>, {
+  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+}>>;
+/**
+ * Define a publisher-first relationship for event-oriented messaging with topic exchange.
+ *
+ * This builder enforces consistency by:
+ * 1. Ensuring the publisher and consumer use the same message schema
+ * 2. The publisher uses a concrete routing key (e.g., 'order.created')
+ * 3. Consumers can optionally specify routing key patterns (e.g., 'order.*') or use the default
+ *
+ * Use this pattern for events where publishers emit with specific routing keys,
+ * and consumers can subscribe with patterns. This is less common than the consumer-first pattern.
+ *
+ * @param exchange - The exchange to publish to (topic type)
+ * @param message - The message definition (schema and metadata)
+ * @param options - Binding configuration (routingKey is required)
+ * @param options.routingKey - The concrete routing key for the publisher
+ * @returns A publisher-first result with publisher and consumer factory that accepts optional routing key patterns
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
  * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
  * const orderMessage = defineMessage(
  *   z.object({
@@ -969,43 +1176,46 @@ declare function definePublisherFirst<TMessage extends MessageDefinition>(exchan
  *   })
  * );
  *
- * // Create publisher-first relationship with routing key (event pattern)
- * const orderCreatedEvent = definePublisherFirst(
+ * // Create publisher-first relationship with concrete routing key
+ * const { publisher: orderCreatedPublisher, createConsumer: createOrderCreatedConsumer } = definePublisherFirst(
  *   ordersExchange,
  *   orderMessage,
- *   { routingKey: 'order.created' }
+ *   { routingKey: 'order.created' }  // Concrete key
  * );
  *
- * // Multiple queues can consume the same event
+ * // Consumers can use patterns or specific keys
  * const orderQueue = defineQueue('order-processing', { durable: true });
- * const analyticsQueue = defineQueue('analytics', { durable: true });
+ * const allOrdersQueue = defineQueue('all-orders', { durable: true });
  *
- * // Use in contract - routing key is consistent across publisher and bindings
- * const { consumer: processConsumer, binding: processBinding } = orderCreatedEvent.createConsumer(orderQueue);
- * const { consumer: analyticsConsumer, binding: analyticsBinding } = orderCreatedEvent.createConsumer(analyticsQueue);
+ * // Use in contract
+ * const { consumer: processConsumer, binding: processBinding } =
+ *   createOrderCreatedConsumer(orderQueue);  // Uses 'order.created'
+ * const { consumer: allOrdersConsumer, binding: allOrdersBinding } =
+ *   createOrderCreatedConsumer(allOrdersQueue, 'order.*');  // Uses pattern
  *
  * const contract = defineContract({
  *   exchanges: { orders: ordersExchange },
- *   queues: { orderQueue, analyticsQueue },
+ *   queues: { orderQueue, allOrdersQueue },
  *   bindings: {
  *     orderBinding: processBinding,
- *     analyticsBinding,
+ *     allOrdersBinding,
  *   },
- *   publishers: { orderCreated: orderCreatedEvent.publisher },
+ *   publishers: { orderCreated: orderCreatedPublisher },
  *   consumers: {
  *     processOrder: processConsumer,
- *     trackOrder: analyticsConsumer,
+ *     trackAllOrders: allOrdersConsumer,
  *   },
  * });
  * ```
  */
-declare function definePublisherFirst<TMessage extends MessageDefinition>(exchange: DirectExchangeDefinition | TopicExchangeDefinition, message: TMessage, options: Omit<Extract<QueueBindingDefinition, {
-  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
-}>, "type" | "queue" | "exchange">): PublisherFirstResult<TMessage, Extract<PublisherDefinition<TMessage>, {
+declare function definePublisherFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(exchange: TopicExchangeDefinition, message: TMessage, options: {
+  routingKey: RoutingKey<TRoutingKey>;
+  arguments?: Record<string, unknown>;
+}): PublisherFirstResultWithRoutingKey<TMessage, Extract<PublisherDefinition<TMessage>, {
   exchange: DirectExchangeDefinition | TopicExchangeDefinition;
-}>>;
+}>, TRoutingKey>;
 /**
- * Consumer-first builder result.
+ * Consumer-first builder result for fanout and direct exchanges.
  *
  * This type represents a consumer with its binding and provides a method to create
  * a publisher that uses the same message schema and routing key.
@@ -1025,7 +1235,37 @@ type ConsumerFirstResult<TMessage extends MessageDefinition, TConsumer extends C
    *
    * @returns A publisher definition with the same message type and routing key
    */
-  createPublisher: () => PublisherDefinition<TMessage>;
+  createPublisher: () => TBinding["exchange"] extends FanoutExchangeDefinition ? Extract<PublisherDefinition<TMessage>, {
+    exchange: FanoutExchangeDefinition;
+  }> : Extract<PublisherDefinition<TMessage>, {
+    exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+  }>;
+};
+/**
+ * Consumer-first builder result for topic exchanges.
+ *
+ * This type represents a consumer with its binding (which may use a pattern) and provides
+ * a method to create a publisher with a concrete routing key that matches the pattern.
+ *
+ * @template TMessage - The message definition
+ * @template TConsumer - The consumer definition
+ * @template TBinding - The queue binding definition
+ */
+type ConsumerFirstResultWithRoutingKey<TMessage extends MessageDefinition, TConsumer extends ConsumerDefinition<TMessage>, TBinding extends QueueBindingDefinition> = {
+  /** The consumer definition */
+  consumer: TConsumer;
+  /** The binding definition connecting the exchange to the queue */
+  binding: TBinding;
+  /**
+   * Create a publisher that sends messages to this consumer.
+   * For topic exchanges, the routing key can be specified to match the binding pattern.
+   *
+   * @param routingKey - The concrete routing key that matches the binding pattern
+   * @returns A publisher definition with the specified routing key
+   */
+  createPublisher: <TPublisherRoutingKey extends string>(routingKey: RoutingKey<TPublisherRoutingKey>) => Extract<PublisherDefinition<TMessage>, {
+    exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+  }>;
 };
 /**
  * Define a consumer-first relationship between a consumer and publisher.
@@ -1058,7 +1298,7 @@ type ConsumerFirstResult<TMessage extends MessageDefinition, TConsumer extends C
  * );
  *
  * // Create consumer-first relationship
- * const notificationConsumerFirst = defineConsumerFirst(
+ * const { consumer: processNotificationConsumer, binding: notificationBinding, createPublisher: createNotificationPublisher } = defineConsumerFirst(
  *   notificationsQueue,
  *   notificationsExchange,
  *   notificationMessage
@@ -1068,9 +1308,9 @@ type ConsumerFirstResult<TMessage extends MessageDefinition, TConsumer extends C
  * const contract = defineContract({
  *   exchanges: { notifications: notificationsExchange },
  *   queues: { notificationsQueue },
- *   bindings: { notificationBinding: notificationConsumerFirst.binding },
- *   publishers: { sendNotification: notificationConsumerFirst.createPublisher() },
- *   consumers: { processNotification: notificationConsumerFirst.consumer },
+ *   bindings: { notificationBinding },
+ *   publishers: { sendNotification: createNotificationPublisher() },
+ *   consumers: { processNotification: processNotificationConsumer },
  * });
  * ```
  */
@@ -1091,7 +1331,7 @@ declare function defineConsumerFirst<TMessage extends MessageDefinition>(queue:
  * send messages with the correct type and routing key.
  *
  * @param queue - The queue to consume from
- * @param exchange - The exchange that routes to the queue (direct or topic type)
+ * @param exchange - The exchange that routes to the queue (direct type)
  * @param message - The message definition (schema and metadata)
  * @param options - Binding configuration (routingKey is required)
  * @param options.routingKey - The routing key for message routing
@@ -1111,7 +1351,7 @@ declare function defineConsumerFirst<TMessage extends MessageDefinition>(queue:
  * );
  *
  * // Create consumer-first relationship with routing key
- * const taskConsumerFirst = defineConsumerFirst(
+ * const { consumer: processTaskConsumer, binding: taskBinding, createPublisher: createTaskPublisher } = defineConsumerFirst(
  *   taskQueue,
  *   tasksExchange,
  *   taskMessage,
@@ -1122,17 +1362,76 @@ declare function defineConsumerFirst<TMessage extends MessageDefinition>(queue:
  * const contract = defineContract({
  *   exchanges: { tasks: tasksExchange },
  *   queues: { taskQueue },
- *   bindings: { taskBinding: taskConsumerFirst.binding },
- *   publishers: { executeTask: taskConsumerFirst.createPublisher() },
- *   consumers: { processTask: taskConsumerFirst.consumer },
+ *   bindings: { taskBinding },
+ *   publishers: { executeTask: createTaskPublisher() },
+ *   consumers: { processTask: processTaskConsumer },
  * });
  * ```
  */
-declare function defineConsumerFirst<TMessage extends MessageDefinition>(queue: QueueDefinition, exchange: DirectExchangeDefinition | TopicExchangeDefinition, message: TMessage, options: Omit<Extract<QueueBindingDefinition, {
-  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
-}>, "type" | "queue" | "exchange">): ConsumerFirstResult<TMessage, ConsumerDefinition<TMessage>, Extract<QueueBindingDefinition, {
-  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+declare function defineConsumerFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(queue: QueueDefinition, exchange: DirectExchangeDefinition, message: TMessage, options: {
+  routingKey: RoutingKey<TRoutingKey>;
+  arguments?: Record<string, unknown>;
+}): ConsumerFirstResult<TMessage, ConsumerDefinition<TMessage>, Extract<QueueBindingDefinition, {
+  exchange: DirectExchangeDefinition;
+}>>;
+/**
+ * Define a consumer-first relationship between a consumer and publisher with topic exchange.
+ *
+ * This builder enforces consistency by:
+ * 1. Ensuring the consumer and publisher use the same message schema
+ * 2. The binding uses a routing key pattern (e.g., 'order.*')
+ * 3. The publisher factory accepts a concrete routing key that matches the pattern (e.g., 'order.created')
+ *
+ * Use this when you want to start with a consumer that uses a routing key pattern,
+ * and allow publishers to specify concrete routing keys that match that pattern.
+ *
+ * @param queue - The queue to consume from
+ * @param exchange - The exchange that routes to the queue (topic type)
+ * @param message - The message definition (schema and metadata)
+ * @param options - Binding configuration (routingKey is required)
+ * @param options.routingKey - The routing key pattern for the binding (can use wildcards)
+ * @returns A consumer-first result with consumer, binding, and publisher factory that accepts a routing key
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const orderQueue = defineQueue('order-processing', { durable: true });
+ * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
+ * const orderMessage = defineMessage(
+ *   z.object({
+ *     orderId: z.string(),
+ *     amount: z.number(),
+ *   })
+ * );
+ *
+ * // Create consumer-first relationship with pattern
+ * const { consumer: processOrderConsumer, binding: orderBinding, createPublisher: createOrderPublisher } = defineConsumerFirst(
+ *   orderQueue,
+ *   ordersExchange,
+ *   orderMessage,
+ *   { routingKey: 'order.*' }  // Pattern in binding
+ * );
+ *
+ * // Use in contract - publisher can specify concrete routing key
+ * const contract = defineContract({
+ *   exchanges: { orders: ordersExchange },
+ *   queues: { orderQueue },
+ *   bindings: { orderBinding },
+ *   publishers: {
+ *     orderCreated: createOrderPublisher('order.created'),  // Concrete key
+ *     orderUpdated: createOrderPublisher('order.updated'),  // Concrete key
+ *   },
+ *   consumers: { processOrder: processOrderConsumer },
+ * });
+ * ```
+ */
+declare function defineConsumerFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(queue: QueueDefinition, exchange: TopicExchangeDefinition, message: TMessage, options: {
+  routingKey: BindingPattern<TRoutingKey>;
+  arguments?: Record<string, unknown>;
+}): ConsumerFirstResultWithRoutingKey<TMessage, ConsumerDefinition<TMessage>, Extract<QueueBindingDefinition, {
+  exchange: TopicExchangeDefinition;
 }>>;
 //#endregion
-export { type AnySchema, type BaseExchangeDefinition, type BindingDefinition, type ConsumerDefinition, type ConsumerFirstResult, type ContractDefinition, type DirectExchangeDefinition, type ExchangeBindingDefinition, type ExchangeDefinition, type FanoutExchangeDefinition, type InferConsumerNames, type InferPublisherNames, type MessageDefinition, type PublisherDefinition, type PublisherFirstResult, type QueueBindingDefinition, type QueueDefinition, type TopicExchangeDefinition, defineConsumer, defineConsumerFirst, defineContract, defineExchange, defineExchangeBinding, defineMessage, definePublisher, definePublisherFirst, defineQueue, defineQueueBinding };
+export { type AnySchema, type BaseExchangeDefinition, type BindingDefinition, type BindingPattern, type ConsumerDefinition, type ConsumerFirstResult, type ConsumerFirstResultWithRoutingKey, type ContractDefinition, type DeadLetterConfig, type DirectExchangeDefinition, type ExchangeBindingDefinition, type ExchangeDefinition, type FanoutExchangeDefinition, type InferConsumerNames, type InferPublisherNames, type MatchingRoutingKey, type MessageDefinition, type PublisherDefinition, type PublisherFirstResult, type PublisherFirstResultWithRoutingKey, type QueueBindingDefinition, type QueueDefinition, type RoutingKey, type TopicExchangeDefinition, defineConsumer, defineConsumerFirst, defineContract, defineExchange, defineExchangeBinding, defineMessage, definePublisher, definePublisherFirst, defineQueue, defineQueueBinding };
 //# sourceMappingURL=index.d.mts.map