@amqp-contract/contract 0.12.0 → 0.13.0

package/dist/index.d.cts

@@ -798,7 +798,51 @@ type ConsumerDefinition<TMessage extends MessageDefinition = MessageDefinition>
   message: TMessage;
 };
 /**
- * Complete AMQP contract definition.
+ * Base type for event publisher configuration.
+ *
+ * This is a simplified type used in ContractDefinition. The full generic type
+ * is defined in the builder module.
+ *
+ * @see defineEventPublisher for creating event publishers
+ */
+type EventPublisherConfigBase = {
+  __brand: "EventPublisherConfig";
+  exchange: ExchangeDefinition;
+  message: MessageDefinition;
+  routingKey: string | undefined;
+  arguments?: Record<string, unknown>;
+};
+/**
+ * Base type for command consumer configuration.
+ *
+ * This is a simplified type used in ContractDefinition. The full generic type
+ * is defined in the builder module.
+ *
+ * @see defineCommandConsumer for creating command consumers
+ */
+type CommandConsumerConfigBase = {
+  __brand: "CommandConsumerConfig";
+  consumer: ConsumerDefinition;
+  binding: QueueBindingDefinition;
+  exchange: ExchangeDefinition;
+  message: MessageDefinition;
+  routingKey: string | undefined;
+};
+/**
+ * Base type for event consumer result.
+ *
+ * This is a simplified type used in ContractDefinitionInput. The full generic type
+ * is defined in the builder module.
+ *
+ * @see defineEventConsumer for creating event consumers
+ */
+type EventConsumerResultBase = {
+  __brand: "EventConsumerResult";
+  consumer: ConsumerDefinition;
+  binding: QueueBindingDefinition;
+};
+/**
+ * Complete AMQP contract definition (output type).
  *
  * A contract brings together all AMQP resources into a single, type-safe definition.
  * It defines the complete messaging topology including exchanges, queues, bindings,
@@ -862,6 +906,69 @@ type ContractDefinition = {
    */
   consumers?: Record<string, ConsumerDefinition>;
 };
+/**
+ * Publisher entry that can be passed to defineContract's publishers section.
+ *
+ * Can be either:
+ * - A plain PublisherDefinition from definePublisher
+ * - An EventPublisherConfig from defineEventPublisher (auto-extracted to publisher)
+ */
+type PublisherEntry = PublisherDefinition | EventPublisherConfigBase;
+/**
+ * Consumer entry that can be passed to defineContract's consumers section.
+ *
+ * Can be either:
+ * - A plain ConsumerDefinition from defineConsumer
+ * - An EventConsumerResult from defineEventConsumer (binding auto-extracted)
+ * - A CommandConsumerConfig from defineCommandConsumer (binding auto-extracted)
+ */
+type ConsumerEntry = ConsumerDefinition | EventConsumerResultBase | CommandConsumerConfigBase;
+/**
+ * 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.
+ *
+ * @example
+ * ```typescript
+ * const contract = defineContract({
+ *   exchanges: { orders: ordersExchange },
+ *   queues: { processing: processingQueue },
+ *   publishers: {
+ *     // EventPublisherConfig → auto-extracted to publisher
+ *     orderCreated: defineEventPublisher(ordersExchange, orderMessage, { routingKey: "order.created" }),
+ *   },
+ *   consumers: {
+ *     // CommandConsumerConfig → auto-extracted to consumer + binding
+ *     processOrder: defineCommandConsumer(orderQueue, ordersExchange, orderMessage, { routingKey: "order.process" }),
+ *     // EventConsumerResult → auto-extracted to consumer + binding
+ *     notify: defineEventConsumer(orderCreatedEvent, notificationQueue),
+ *   },
+ * });
+ * ```
+ *
+ * @see defineContract - Processes this input and returns a ContractDefinition
+ */
+type ContractDefinitionInput = Omit<ContractDefinition, "publishers" | "consumers"> & {
+  /**
+   * Named publisher definitions.
+   *
+   * Can accept:
+   * - PublisherDefinition from definePublisher
+   * - EventPublisherConfig from defineEventPublisher (auto-extracted to publisher)
+   */
+  publishers?: Record<string, PublisherEntry>;
+  /**
+   * Named consumer definitions.
+   *
+   * Can accept:
+   * - ConsumerDefinition from defineConsumer
+   * - EventConsumerResult from defineEventConsumer (binding auto-extracted)
+   * - CommandConsumerConfig from defineCommandConsumer (binding auto-extracted)
+   */
+  consumers?: Record<string, ConsumerEntry>;
+};
 /**
  * Extract publisher names from a contract.
  *
@@ -1010,19 +1117,87 @@ 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.
- * If the entry is a QueueWithTtlBackoffInfrastructure, returns the inner queue.
- * Otherwise, returns the entry as-is.
+ *
+ * **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
- * const queue = defineQueue('orders', { retry: { mode: 'ttl-backoff' }, deadLetter: { exchange: dlx } });
- * const plainQueue = extractQueue(queue); // Returns the inner QueueDefinition
+ * import { defineQueue, defineTtlBackoffQueue, extractQueue } from '@amqp-contract/contract';
+ *
+ * // TTL-backoff queue returns a wrapper
+ * const orderQueue = defineTtlBackoffQueue('orders', {
+ *   deadLetterExchange: 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(entry: QueueEntry): QueueDefinition;
 /**
@@ -1088,6 +1263,176 @@ declare function extractQueue(entry: QueueEntry): QueueDefinition;
  * ```
  */
 declare function defineQueue(name: string, options?: DefineQueueOptions): QueueDefinition | QueueWithTtlBackoffInfrastructure;
+/**
+ * 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.
+   */
+  deadLetterExchange: ExchangeDefinition;
+  /**
+   * Optional routing key for dead-lettered messages.
+   */
+  deadLetterRoutingKey?: string;
+  /**
+   * 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', {
+ *   deadLetterExchange: dlx,
+ *   deliveryLimit: 3, // Retry up to 3 times
+ * });
+ *
+ * const contract = defineContract({
+ *   exchanges: { dlx },
+ *   queues: { orderProcessing: orderQueue },
+ *   // ...
+ * });
+ * ```
+ *
+ * @see defineQueue - For full queue configuration options
+ * @see defineTtlBackoffQueue - For queues with exponential backoff retry
+ */
+declare function defineQuorumQueue(name: string, options: DefineQuorumQueueOptions): QuorumQueueDefinition;
+/**
+ * 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 exchange - required for TTL-backoff retry.
+   * Used for routing messages to the wait queue and back.
+   */
+  deadLetterExchange: ExchangeDefinition;
+  /**
+   * Optional routing key for dead-lettered messages.
+   */
+  deadLetterRoutingKey?: string;
+  /**
+   * 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>;
+};
+/**
+ * Create a queue with TTL-backoff retry (exponential backoff).
+ *
+ * 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
+ *
+ * **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
+ *
+ * **Returns:** A `QueueWithTtlBackoffInfrastructure` object that includes the
+ * main queue, wait queue, and bindings. Pass this directly to `defineContract`
+ * and it will be expanded automatically.
+ *
+ * @param name - The queue name
+ * @param options - Configuration options
+ * @returns A queue with TTL-backoff infrastructure
+ *
+ * @example
+ * ```typescript
+ * const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
+ *
+ * const orderQueue = defineTtlBackoffQueue('order-processing', {
+ *   deadLetterExchange: dlx,
+ *   maxRetries: 5,
+ *   initialDelayMs: 1000,  // Start with 1s delay
+ *   maxDelayMs: 30000,     // Cap at 30s
+ * });
+ *
+ * const contract = defineContract({
+ *   exchanges: { dlx },
+ *   queues: { orderProcessing: orderQueue }, // Wait queue auto-added
+ *   // ... bindings auto-generated
+ * });
+ *
+ * // To access the underlying queue definition (e.g., for the queue name):
+ * import { extractQueue } from '@amqp-contract/contract';
+ * const queueName = extractQueue(orderQueue).name;
+ * ```
+ *
+ * @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
+ */
+declare function defineTtlBackoffQueue(name: string, options: DefineTtlBackoffQueueOptions): QueueWithTtlBackoffInfrastructure;
 //#endregion
 //#region src/builder/binding.d.ts
 /**
@@ -1219,6 +1564,19 @@ declare function defineExchangeBinding(destination: ExchangeDefinition, source:
  *
  * The message schema is validated when publishing to ensure type safety.
  *
+ * **Which pattern to use:**
+ *
+ * | Pattern | Best for | Description |
+ * |---------|----------|-------------|
+ * | `definePublisher` + `defineConsumer` | Independent definition | Define publishers and consumers separately with manual schema consistency |
+ * | `defineEventPublisher` + `defineEventConsumer` | Event broadcasting | Define event publisher first, create consumers that subscribe to it |
+ * | `defineCommandConsumer` + `defineCommandPublisher` | Task queues | Define command consumer first, create publishers that send commands to it |
+ *
+ * Use `defineEventPublisher` when:
+ * - One publisher feeds multiple consumers
+ * - 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 message - The message definition with payload schema
  * @param options - Optional publisher configuration
@@ -1239,6 +1597,9 @@ declare function defineExchangeBinding(destination: ExchangeDefinition, source:
  *
  * const logPublisher = definePublisher(logsExchange, logMessage);
  * ```
+ *
+ * @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;
@@ -1253,6 +1614,19 @@ declare function definePublisher<TMessage extends MessageDefinition>(exchange: F
  *
  * The message schema is validated when publishing to ensure type safety.
  *
+ * **Which pattern to use:**
+ *
+ * | Pattern | Best for | Description |
+ * |---------|----------|-------------|
+ * | `definePublisher` + `defineConsumer` | Independent definition | Define publishers and consumers separately with manual schema consistency |
+ * | `defineEventPublisher` + `defineEventConsumer` | Event broadcasting | Define event publisher first, create consumers that subscribe to it |
+ * | `defineCommandConsumer` + `defineCommandPublisher` | Task queues | Define command consumer first, create publishers that send commands to it |
+ *
+ * Use `defineEventPublisher` when:
+ * - One publisher feeds multiple consumers
+ * - You want automatic schema consistency between publisher and consumers
+ * - You're building event-driven architectures
+ *
  * @param exchange - The direct or topic exchange definition to publish to
  * @param message - The message definition with payload schema
  * @param options - Publisher configuration (routingKey is required)
@@ -1279,6 +1653,9 @@ declare function definePublisher<TMessage extends MessageDefinition>(exchange: F
  *   routingKey: 'order.created'
  * });
  * ```
+ *
+ * @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: DirectExchangeDefinition | TopicExchangeDefinition, message: TMessage, options: Omit<Extract<PublisherDefinition<TMessage>, {
   exchange: DirectExchangeDefinition | TopicExchangeDefinition;
@@ -1296,6 +1673,19 @@ declare function definePublisher<TMessage extends MessageDefinition>(exchange: D
  * Consumers are associated with a specific queue and message type. When you create a worker
  * with this consumer, it will process messages from the queue according to the schema.
  *
+ * **Which pattern to use:**
+ *
+ * | Pattern | Best for | Description |
+ * |---------|----------|-------------|
+ * | `definePublisher` + `defineConsumer` | Independent definition | Define publishers and consumers separately with manual schema consistency |
+ * | `defineEventPublisher` + `defineEventConsumer` | Event broadcasting | Define event publisher first, create consumers that subscribe to it |
+ * | `defineCommandConsumer` + `defineCommandPublisher` | Task queues | Define command consumer first, create publishers that send commands to it |
+ *
+ * Use `defineCommandConsumer` when:
+ * - One consumer receives from multiple publishers
+ * - You want automatic schema consistency between consumer and publishers
+ * - You're building task queue or command patterns
+ *
  * @param queue - The queue definition to consume from
  * @param message - The message definition with payload schema
  * @param options - Optional consumer configuration
@@ -1328,10 +1718,19 @@ declare function definePublisher<TMessage extends MessageDefinition>(exchange: D
  * //   connection
  * // });
  * ```
+ *
+ * @see defineCommandConsumer - For task queue patterns with automatic schema consistency
+ * @see defineEventPublisher - For event-driven patterns with automatic schema consistency
  */
 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.
  *
@@ -1401,7 +1800,7 @@ declare function defineConsumer<TMessage extends MessageDefinition>(queue: Queue
  * // - handler: async (message: { orderId: string, amount: number }) => void
  * ```
  */
-declare function defineContract<TContract extends ContractDefinition>(definition: TContract): TContract;
+declare function defineContract<TContract extends ContractDefinitionInput>(definition: TContract): ContractOutput<TContract>;
 //#endregion
 //#region src/builder/routing-types.d.ts
 /**
@@ -1481,460 +1880,396 @@ type MatchesPattern<Key extends string, Pattern extends string> = Pattern extend
  */
 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;
 //#endregion
-//#region src/builder/publisher-first.d.ts
+//#region src/builder/event.d.ts
 /**
- * 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.
+ * Configuration for an event publisher.
  *
- * This pattern is suitable for event-oriented messaging where publishers
- * emit events without knowing which queues will consume them.
+ * Events are published without knowing who consumes them. Multiple consumers
+ * can subscribe to the same event. This follows the pub/sub pattern where
+ * publishers broadcast events and consumers subscribe to receive them.
  *
  * @template TMessage - The message definition
- * @template TPublisher - The publisher definition
+ * @template TExchange - The exchange definition
+ * @template TRoutingKey - The routing key type (undefined for fanout)
  */
-type PublisherFirstResult<TMessage extends MessageDefinition, TPublisher extends PublisherDefinition<TMessage>> = {
-  /** The publisher definition */
-  publisher: TPublisher;
-  /**
-   * Create a consumer that receives messages from this publisher.
-   * The consumer will automatically use the same message schema and
-   * a binding will be created with the same routing key.
-   *
-   * @param queue - The queue (or queue with infrastructure) that will consume the messages
-   * @returns An object with the consumer definition and binding
-   */
-  createConsumer: (queue: QueueEntry) => {
-    consumer: ConsumerDefinition<TMessage>;
-    binding: QueueBindingDefinition;
-  };
+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 */
+  arguments?: Record<string, unknown>;
 };
 /**
- * Publisher-first builder result for topic exchanges.
+ * Result from defineEventConsumer.
  *
- * 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.
+ * Contains the consumer definition and binding needed to subscribe to an event.
+ * Can be used directly in defineContract's consumers section - the binding
+ * will be automatically extracted.
  *
  * @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 (or queue with infrastructure) 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: QueueEntry, routingKey?: BindingPattern<TConsumerRoutingKey>) => {
-    consumer: ConsumerDefinition<TMessage>;
-    binding: QueueBindingDefinition;
-  };
+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;
 };
 /**
- * Define a publisher-first relationship for event-oriented messaging.
+ * Define an event publisher for broadcasting messages via fanout exchange.
  *
- * This builder enforces consistency by:
- * 1. Ensuring the publisher and consumer use the same message schema
- * 2. Linking the routing key from the publisher to the binding
+ * Events are published without knowing who consumes them. Multiple consumers
+ * can subscribe to the same event using `defineEventConsumer`.
  *
- * 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 (fanout type)
+ * @param exchange - The fanout exchange to publish to
  * @param message - The message definition (schema and metadata)
- * @param options - Optional binding configuration
- * @returns A publisher-first result with publisher and consumer factory
+ * @returns An event publisher configuration
  *
  * @example
  * ```typescript
- * import { z } from 'zod';
- *
  * const logsExchange = defineExchange('logs', 'fanout', { durable: true });
- * const logMessage = defineMessage(
- *   z.object({
- *     level: z.enum(['info', 'warn', 'error']),
- *     message: z.string(),
- *   })
- * );
- *
- * // Create publisher-first relationship (event pattern)
- * 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 } = createLogConsumer(logsQueue1);
- * const { consumer: consumer2, binding: binding2 } = createLogConsumer(logsQueue2);
- *
- * const contract = defineContract({
- *   exchanges: { logs: logsExchange },
- *   queues: { logsQueue1, logsQueue2 },
- *   bindings: {
- *     logBinding1: binding1,
- *     logBinding2: binding2,
- *   },
- *   publishers: { publishLog },
- *   consumers: {
- *     consumeLog1: consumer1,
- *     consumeLog2: consumer2,
- *   },
- * });
+ * 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 definePublisherFirst<TMessage extends MessageDefinition>(exchange: FanoutExchangeDefinition, message: TMessage, options?: Omit<Extract<QueueBindingDefinition, {
-  exchange: FanoutExchangeDefinition;
-}>, "type" | "queue" | "exchange" | "routingKey">): PublisherFirstResult<TMessage, Extract<PublisherDefinition<TMessage>, {
-  exchange: FanoutExchangeDefinition;
-}>>;
+declare function defineEventPublisher<TMessage extends MessageDefinition>(exchange: FanoutExchangeDefinition, message: TMessage): EventPublisherConfig<TMessage, FanoutExchangeDefinition, undefined>;
 /**
- * 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
- * 2. Linking the routing key from the publisher to the binding
+ * Define an event publisher for broadcasting messages via direct exchange.
  *
- * 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.
+ * Events are published with a specific routing key. Consumers will receive
+ * messages that match the routing key exactly.
  *
- * @param exchange - The exchange to publish to (direct type)
+ * @param exchange - The direct exchange to publish to
  * @param message - The message definition (schema and metadata)
- * @param options - Binding configuration (routingKey is required)
+ * @param options - Configuration with required routing key
  * @param options.routingKey - The routing key for message routing
- * @returns A publisher-first result with publisher and consumer factory
+ * @param options.arguments - Additional AMQP arguments
+ * @returns An event publisher configuration
  *
  * @example
  * ```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' }
- * );
+ * const taskMessage = defineMessage(z.object({ taskId: z.string() }));
  *
- * // 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 },
+ * const taskEvent = defineEventPublisher(tasksExchange, taskMessage, {
+ *   routingKey: 'task.execute',
  * });
  * ```
  */
-declare function definePublisherFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(exchange: DirectExchangeDefinition, message: TMessage, options: {
+declare function defineEventPublisher<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;
-}>>;
+}): EventPublisherConfig<TMessage, DirectExchangeDefinition, TRoutingKey>;
 /**
- * Define a publisher-first relationship for event-oriented messaging with topic exchange.
+ * Define an event publisher for broadcasting messages via 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
+ * Events are published with a concrete routing key. Consumers can subscribe
+ * using patterns (with * and # wildcards) to receive matching messages.
  *
- * 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 exchange - The topic exchange to publish to
  * @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
+ * @param options - Configuration with required routing key
+ * @param options.routingKey - The concrete routing key (no wildcards)
+ * @param options.arguments - Additional AMQP arguments
+ * @returns An event publisher configuration
  *
  * @example
  * ```typescript
- * import { z } from 'zod';
- *
  * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
- * const orderMessage = defineMessage(
- *   z.object({
- *     orderId: z.string(),
- *     amount: z.number(),
- *   })
- * );
+ * const orderMessage = defineMessage(z.object({
+ *   orderId: z.string(),
+ *   amount: z.number(),
+ * }));
+ *
+ * // Publisher uses concrete routing key
+ * const orderCreatedEvent = defineEventPublisher(ordersExchange, orderMessage, {
+ *   routingKey: 'order.created',
+ * });
  *
- * // Create publisher-first relationship with concrete routing key
- * const { publisher: orderCreatedPublisher, createConsumer: createOrderCreatedConsumer } = definePublisherFirst(
- *   ordersExchange,
- *   orderMessage,
- *   { routingKey: 'order.created' }  // Concrete key
+ * // Consumer can use pattern
+ * const { consumer, binding } = defineEventConsumer(
+ *   orderCreatedEvent,
+ *   allOrdersQueue,
+ *   { routingKey: 'order.*' },
  * );
+ * ```
+ */
+declare function defineEventPublisher<TMessage extends MessageDefinition, TRoutingKey extends string>(exchange: TopicExchangeDefinition, message: TMessage, options: {
+  routingKey: RoutingKey<TRoutingKey>;
+  arguments?: Record<string, unknown>;
+}): EventPublisherConfig<TMessage, TopicExchangeDefinition, TRoutingKey>;
+/**
+ * Create a consumer that subscribes to an event from a fanout exchange.
  *
- * // Consumers can use patterns or specific keys
- * const orderQueue = defineQueue('order-processing', { durable: true });
- * const allOrdersQueue = defineQueue('all-orders', { durable: true });
+ * @param eventPublisher - The event publisher configuration
+ * @param queue - The queue that will receive messages
+ * @param options - Optional binding configuration
+ * @returns An object with the consumer definition and binding
  *
- * // Use in contract
- * const { consumer: processConsumer, binding: processBinding } =
- *   createOrderCreatedConsumer(orderQueue);  // Uses 'order.created'
- * const { consumer: allOrdersConsumer, binding: allOrdersBinding } =
- *   createOrderCreatedConsumer(allOrdersQueue, 'order.*');  // Uses pattern
+ * @example
+ * ```typescript
+ * const logEvent = defineEventPublisher(logsExchange, logMessage);
+ * const { consumer, binding } = defineEventConsumer(logEvent, logsQueue);
+ * ```
+ */
+declare function defineEventConsumer<TMessage extends MessageDefinition>(eventPublisher: EventPublisherConfig<TMessage, FanoutExchangeDefinition, undefined>, queue: QueueEntry, options?: {
+  arguments?: Record<string, unknown>;
+}): EventConsumerResult<TMessage>;
+/**
+ * Create a consumer that subscribes to an event from a direct exchange.
  *
- * const contract = defineContract({
- *   exchanges: { orders: ordersExchange },
- *   queues: { orderQueue, allOrdersQueue },
- *   bindings: {
- *     orderBinding: processBinding,
- *     allOrdersBinding,
- *   },
- *   publishers: { orderCreated: orderCreatedPublisher },
- *   consumers: {
- *     processOrder: processConsumer,
- *     trackAllOrders: allOrdersConsumer,
- *   },
+ * @param eventPublisher - The event publisher configuration
+ * @param queue - The queue that will receive messages
+ * @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?: {
+  arguments?: Record<string, unknown>;
+}): EventConsumerResult<TMessage>;
+/**
+ * Create a consumer that subscribes to an event from a topic exchange.
+ *
+ * For topic exchanges, the consumer can optionally override the routing key
+ * with a pattern to subscribe to multiple events.
+ *
+ * @param eventPublisher - The event publisher configuration
+ * @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)
+ * @returns An object with the consumer definition and binding
+ *
+ * @example
+ * ```typescript
+ * const orderCreatedEvent = defineEventPublisher(ordersExchange, orderMessage, {
+ *   routingKey: 'order.created',
+ * });
+ *
+ * // Use exact routing key from publisher
+ * const { consumer: exactConsumer } = defineEventConsumer(orderCreatedEvent, exactQueue);
+ *
+ * // Override with pattern to receive all order events
+ * const { consumer: allConsumer } = defineEventConsumer(orderCreatedEvent, allQueue, {
+ *   routingKey: 'order.*',
  * });
  * ```
  */
-declare function definePublisherFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(exchange: TopicExchangeDefinition, message: TMessage, options: {
-  routingKey: RoutingKey<TRoutingKey>;
+declare function defineEventConsumer<TMessage extends MessageDefinition, TRoutingKey extends string, TConsumerRoutingKey extends string = TRoutingKey>(eventPublisher: EventPublisherConfig<TMessage, TopicExchangeDefinition, TRoutingKey>, queue: QueueEntry, options?: {
+  routingKey?: BindingPattern<TConsumerRoutingKey>;
   arguments?: Record<string, unknown>;
-}): PublisherFirstResultWithRoutingKey<TMessage, Extract<PublisherDefinition<TMessage>, {
-  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
-}>, TRoutingKey>;
-//#endregion
-//#region src/builder/consumer-first.d.ts
+}): EventConsumerResult<TMessage>;
 /**
- * Consumer-first builder result for fanout and direct exchanges.
+ * Type guard to check if a value is an EventPublisherConfig.
  *
- * 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.
+ * @param value - The value to check
+ * @returns True if the value is an EventPublisherConfig
+ */
+declare function isEventPublisherConfig(value: unknown): value is EventPublisherConfig<MessageDefinition, ExchangeDefinition, string | undefined>;
+/**
+ * Type guard to check if a value is an EventConsumerResult.
  *
- * @template TMessage - The message definition
- * @template TConsumer - The consumer definition
- * @template TBinding - The queue binding definition
+ * @param value - The value to check
+ * @returns True if the value is an EventConsumerResult
  */
-type ConsumerFirstResult<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.
-   * The publisher will automatically use the same message schema and routing key.
-   *
-   * @returns A publisher definition with the same message type and routing key
-   */
-  createPublisher: () => TBinding["exchange"] extends FanoutExchangeDefinition ? Extract<PublisherDefinition<TMessage>, {
-    exchange: FanoutExchangeDefinition;
-  }> : Extract<PublisherDefinition<TMessage>, {
-    exchange: DirectExchangeDefinition | TopicExchangeDefinition;
-  }>;
-};
+declare function isEventConsumerResult(value: unknown): value is EventConsumerResult<MessageDefinition>;
+//#endregion
+//#region src/builder/command.d.ts
 /**
- * Consumer-first builder result for topic exchanges.
+ * Configuration for a command consumer.
  *
- * 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.
+ * Commands are sent by one or more publishers to a single consumer (task queue pattern).
+ * The consumer "owns" the queue, and publishers send commands to it.
  *
  * @template TMessage - The message definition
- * @template TConsumer - The consumer definition
- * @template TBinding - The queue binding definition
+ * @template TExchange - The exchange definition
+ * @template TRoutingKey - The routing key type (undefined for fanout)
  */
-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;
-  }>;
+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 */
+  routingKey: TRoutingKey;
 };
 /**
- * Define a consumer-first relationship between a consumer and publisher.
- *
- * This builder enforces consistency by:
- * 1. Ensuring the consumer and publisher use the same message schema
- * 2. Linking the routing key from the binding to the publisher
- * 3. Creating a binding that connects the exchange to the queue
+ * Define a command consumer for receiving commands via fanout exchange.
  *
- * Use this when you want to start with a consumer and ensure publishers
- * send messages of the correct type.
+ * Commands are sent by publishers to a specific queue. The consumer "owns" the
+ * queue and defines what commands it accepts.
  *
- * @param queue - The queue to consume from
- * @param exchange - The exchange that routes to the queue (fanout type)
+ * @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
- * @returns A consumer-first result with consumer, binding, and publisher factory
+ * @returns A command consumer configuration
  *
  * @example
  * ```typescript
- * import { z } from 'zod';
+ * const tasksExchange = defineExchange('tasks', 'fanout', { durable: true });
+ * const taskMessage = defineMessage(z.object({ taskId: z.string() }));
  *
- * const notificationsQueue = defineQueue('notifications', { durable: true });
- * const notificationsExchange = defineExchange('notifications', 'fanout', { durable: true });
- * const notificationMessage = defineMessage(
- *   z.object({
- *     userId: z.string(),
- *     message: z.string(),
- *   })
- * );
+ * // Consumer owns the queue
+ * const executeTask = defineCommandConsumer(taskQueue, tasksExchange, taskMessage);
  *
- * // Create consumer-first relationship
- * const { consumer: processNotificationConsumer, binding: notificationBinding, createPublisher: createNotificationPublisher } = defineConsumerFirst(
- *   notificationsQueue,
- *   notificationsExchange,
- *   notificationMessage
- * );
- *
- * // Use in contract
- * const contract = defineContract({
- *   exchanges: { notifications: notificationsExchange },
- *   queues: { notificationsQueue },
- *   bindings: { notificationBinding },
- *   publishers: { sendNotification: createNotificationPublisher() },
- *   consumers: { processNotification: processNotificationConsumer },
- * });
+ * // Publishers send commands to it
+ * const sendTask = defineCommandPublisher(executeTask);
  * ```
  */
-declare function defineConsumerFirst<TMessage extends MessageDefinition>(queue: QueueEntry, exchange: FanoutExchangeDefinition, message: TMessage, options?: Omit<Extract<QueueBindingDefinition, {
-  exchange: FanoutExchangeDefinition;
-}>, "type" | "queue" | "exchange" | "routingKey">): ConsumerFirstResult<TMessage, ConsumerDefinition<TMessage>, Extract<QueueBindingDefinition, {
-  exchange: FanoutExchangeDefinition;
-}>>;
+declare function defineCommandConsumer<TMessage extends MessageDefinition>(queue: QueueEntry, exchange: FanoutExchangeDefinition, message: TMessage): CommandConsumerConfig<TMessage, FanoutExchangeDefinition, undefined>;
 /**
- * Define a consumer-first relationship between a consumer and publisher.
- *
- * This builder enforces consistency by:
- * 1. Ensuring the consumer and publisher use the same message schema
- * 2. Linking the routing key from the binding to the publisher
- * 3. Creating a binding that connects the exchange to the queue
+ * Define a command consumer for receiving commands via direct exchange.
  *
- * Use this when you want to start with a consumer and ensure publishers
- * send messages with the correct type and routing key.
+ * Commands are sent by publishers with a specific routing key that matches
+ * the binding pattern.
  *
- * @param queue - The queue to consume from
- * @param exchange - The exchange that routes to the queue (direct type)
+ * @param queue - The queue that will receive commands
+ * @param exchange - The direct exchange that routes commands
  * @param message - The message definition (schema and metadata)
- * @param options - Binding configuration (routingKey is required)
- * @param options.routingKey - The routing key for message routing
- * @returns A consumer-first result with consumer, binding, and publisher factory
+ * @param options - Configuration with required routing key
+ * @param options.routingKey - The routing key for the binding
+ * @param options.arguments - Additional AMQP arguments
+ * @returns A command consumer configuration
  *
  * @example
  * ```typescript
- * import { z } from 'zod';
- *
- * const taskQueue = defineQueue('tasks', { durable: true });
  * const tasksExchange = defineExchange('tasks', 'direct', { durable: true });
- * const taskMessage = defineMessage(
- *   z.object({
- *     taskId: z.string(),
- *     payload: z.record(z.unknown()),
- *   })
- * );
- *
- * // Create consumer-first relationship with routing key
- * const { consumer: processTaskConsumer, binding: taskBinding, createPublisher: createTaskPublisher } = defineConsumerFirst(
- *   taskQueue,
- *   tasksExchange,
- *   taskMessage,
- *   { routingKey: 'task.execute' }
- * );
+ * const taskMessage = defineMessage(z.object({ taskId: z.string() }));
  *
- * // Use in contract - routing key is consistent across consumer and publisher
- * const contract = defineContract({
- *   exchanges: { tasks: tasksExchange },
- *   queues: { taskQueue },
- *   bindings: { taskBinding },
- *   publishers: { executeTask: createTaskPublisher() },
- *   consumers: { processTask: processTaskConsumer },
+ * const executeTask = defineCommandConsumer(taskQueue, tasksExchange, taskMessage, {
+ *   routingKey: 'task.execute',
  * });
+ *
+ * const sendTask = defineCommandPublisher(executeTask);
  * ```
  */
-declare function defineConsumerFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(queue: QueueEntry, exchange: DirectExchangeDefinition, message: TMessage, options: {
+declare function defineCommandConsumer<TMessage extends MessageDefinition, TRoutingKey extends string>(queue: QueueEntry, exchange: DirectExchangeDefinition, message: TMessage, options: {
   routingKey: RoutingKey<TRoutingKey>;
   arguments?: Record<string, unknown>;
-}): ConsumerFirstResult<TMessage, ConsumerDefinition<TMessage>, Extract<QueueBindingDefinition, {
-  exchange: DirectExchangeDefinition;
-}>>;
+}): CommandConsumerConfig<TMessage, DirectExchangeDefinition, TRoutingKey>;
 /**
- * Define a consumer-first relationship between a consumer and publisher with topic exchange.
+ * Define a command consumer for receiving commands via 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')
+ * The consumer binds with a routing key pattern (can use * and # wildcards).
+ * Publishers then send commands with concrete routing keys that match the pattern.
  *
- * 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 queue - The queue that will receive commands
+ * @param exchange - The topic exchange that routes commands
  * @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
+ * @param options - Configuration with required routing key pattern
+ * @param options.routingKey - The routing key pattern for the binding
+ * @param options.arguments - Additional AMQP arguments
+ * @returns A command consumer configuration
  *
  * @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(),
- *   })
- * );
+ * const orderMessage = defineMessage(z.object({ orderId: z.string() }));
  *
- * // Create consumer-first relationship with pattern
- * const { consumer: processOrderConsumer, binding: orderBinding, createPublisher: createOrderPublisher } = defineConsumerFirst(
- *   orderQueue,
- *   ordersExchange,
- *   orderMessage,
- *   { routingKey: 'order.*' }  // Pattern in binding
- * );
+ * // Consumer uses pattern to receive multiple command types
+ * const processOrder = defineCommandConsumer(orderQueue, ordersExchange, orderMessage, {
+ *   routingKey: 'order.*',
+ * });
  *
- * // 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 },
+ * // Publishers send with concrete keys
+ * const createOrder = defineCommandPublisher(processOrder, {
+ *   routingKey: 'order.create',
+ * });
+ * const updateOrder = defineCommandPublisher(processOrder, {
+ *   routingKey: 'order.update',
  * });
  * ```
  */
-declare function defineConsumerFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(queue: QueueEntry, exchange: TopicExchangeDefinition, message: TMessage, options: {
+declare function defineCommandConsumer<TMessage extends MessageDefinition, TRoutingKey extends string>(queue: QueueEntry, exchange: TopicExchangeDefinition, message: TMessage, options: {
   routingKey: BindingPattern<TRoutingKey>;
   arguments?: Record<string, unknown>;
-}): ConsumerFirstResultWithRoutingKey<TMessage, ConsumerDefinition<TMessage>, Extract<QueueBindingDefinition, {
+}): CommandConsumerConfig<TMessage, TopicExchangeDefinition, TRoutingKey>;
+/**
+ * Create a publisher that sends commands to a fanout exchange consumer.
+ *
+ * @param commandConsumer - The command consumer configuration
+ * @returns A publisher definition
+ *
+ * @example
+ * ```typescript
+ * const executeTask = defineCommandConsumer(taskQueue, fanoutExchange, taskMessage);
+ * const sendTask = defineCommandPublisher(executeTask);
+ * ```
+ */
+declare function defineCommandPublisher<TMessage extends MessageDefinition>(commandConsumer: CommandConsumerConfig<TMessage, FanoutExchangeDefinition, undefined>): {
+  message: TMessage;
+  exchange: FanoutExchangeDefinition;
+};
+/**
+ * Create a publisher that sends commands to a direct exchange consumer.
+ *
+ * @param commandConsumer - The command consumer configuration
+ * @returns A publisher definition
+ */
+declare function defineCommandPublisher<TMessage extends MessageDefinition, TRoutingKey extends string>(commandConsumer: CommandConsumerConfig<TMessage, DirectExchangeDefinition, TRoutingKey>): {
+  message: TMessage;
+  exchange: DirectExchangeDefinition;
+  routingKey: string;
+};
+/**
+ * Create a publisher that sends commands to a topic exchange consumer.
+ *
+ * For topic exchanges where the consumer uses a pattern, the publisher can
+ * optionally specify a concrete routing key that matches the pattern.
+ *
+ * @param commandConsumer - The command consumer configuration
+ * @param options - Optional publisher configuration
+ * @param options.routingKey - Override routing key (must match consumer's pattern)
+ * @returns A publisher definition
+ *
+ * @example
+ * ```typescript
+ * // Consumer binds with pattern
+ * const processOrder = defineCommandConsumer(orderQueue, topicExchange, orderMessage, {
+ *   routingKey: 'order.*',
+ * });
+ *
+ * // Publisher uses concrete key matching the pattern
+ * const createOrder = defineCommandPublisher(processOrder, {
+ *   routingKey: 'order.create',
+ * });
+ * ```
+ */
+declare function defineCommandPublisher<TMessage extends MessageDefinition, TRoutingKey extends string, TPublisherRoutingKey extends string = TRoutingKey>(commandConsumer: CommandConsumerConfig<TMessage, TopicExchangeDefinition, TRoutingKey>, options?: {
+  routingKey?: RoutingKey<TPublisherRoutingKey>;
+}): {
+  message: TMessage;
   exchange: TopicExchangeDefinition;
-}>>;
+  routingKey: string;
+};
+/**
+ * Type guard to check if a value is a CommandConsumerConfig.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a CommandConsumerConfig
+ */
+declare function isCommandConsumerConfig(value: unknown): value is CommandConsumerConfig<MessageDefinition, ExchangeDefinition, string | undefined>;
 //#endregion
 //#region src/builder/ttl-backoff.d.ts
 /**
@@ -2011,5 +2346,5 @@ declare function defineTtlBackoffRetryInfrastructure(queueEntry: QueueEntry, opt
   waitQueueDurable?: boolean;
 }): TtlBackoffRetryInfrastructure;
 //#endregion
-export { type AnySchema, type BaseExchangeDefinition, type BindingDefinition, type BindingPattern, type ClassicQueueDefinition, type ClassicQueueOptions, type CompressionAlgorithm, type ConsumerDefinition, type ConsumerFirstResult, type ConsumerFirstResultWithRoutingKey, type ContractDefinition, type DeadLetterConfig, type DefineQueueOptions, 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 QueueEntry, type QueueType, type QueueWithTtlBackoffInfrastructure, type QuorumNativeRetryOptions, type QuorumQueueDefinition, type QuorumQueueOptions, type ResolvedRetryOptions, type ResolvedTtlBackoffRetryOptions, type RoutingKey, type TopicExchangeDefinition, type TtlBackoffRetryInfrastructure, type TtlBackoffRetryOptions, defineConsumer, defineConsumerFirst, defineContract, defineExchange, defineExchangeBinding, defineMessage, definePublisher, definePublisherFirst, defineQueue, defineQueueBinding, defineTtlBackoffRetryInfrastructure, extractQueue };
+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 };
 //# sourceMappingURL=index.d.cts.map