@amqp-contract/contract 0.3.4 → 0.4.0

package/dist/index.d.mts

@@ -855,6 +855,284 @@ declare function defineConsumer<TMessage extends MessageDefinition>(queue: Queue
  * ```
  */
 declare function defineContract<TContract extends ContractDefinition>(definition: TContract): TContract;
+/**
+ * Publisher-first builder result.
+ *
+ * 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.
+ *
+ * This pattern is suitable for event-oriented messaging where publishers
+ * emit events without knowing which queues will consume them.
+ *
+ * @template TMessage - The message definition
+ * @template TPublisher - The publisher definition
+ */
+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 that will consume the messages
+   * @returns An object with the consumer definition and binding
+   */
+  createConsumer: (queue: QueueDefinition) => {
+    consumer: ConsumerDefinition<TMessage>;
+    binding: QueueBindingDefinition;
+  };
+};
+/**
+ * Define a publisher-first relationship for event-oriented messaging.
+ *
+ * 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
+ *
+ * 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 message - The message definition (schema and metadata)
+ * @param options - Optional binding configuration
+ * @returns A publisher-first result with publisher and consumer factory
+ *
+ * @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 logEvent = 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 contract = defineContract({
+ *   exchanges: { logs: logsExchange },
+ *   queues: { logsQueue1, logsQueue2 },
+ *   bindings: {
+ *     logBinding1: binding1,
+ *     logBinding2: binding2,
+ *   },
+ *   publishers: { publishLog: logEvent.publisher },
+ *   consumers: {
+ *     consumeLog1: consumer1,
+ *     consumeLog2: consumer2,
+ *   },
+ * });
+ * ```
+ */
+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;
+}>>;
+/**
+ * Define a publisher-first relationship for event-oriented messaging.
+ *
+ * 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
+ *
+ * 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 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 publisher-first result with publisher and consumer factory
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
+ * const orderMessage = defineMessage(
+ *   z.object({
+ *     orderId: z.string(),
+ *     amount: z.number(),
+ *   })
+ * );
+ *
+ * // Create publisher-first relationship with routing key (event pattern)
+ * const orderCreatedEvent = definePublisherFirst(
+ *   ordersExchange,
+ *   orderMessage,
+ *   { routingKey: 'order.created' }
+ * );
+ *
+ * // Multiple queues can consume the same event
+ * const orderQueue = defineQueue('order-processing', { durable: true });
+ * const analyticsQueue = defineQueue('analytics', { 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);
+ *
+ * const contract = defineContract({
+ *   exchanges: { orders: ordersExchange },
+ *   queues: { orderQueue, analyticsQueue },
+ *   bindings: {
+ *     orderBinding: processBinding,
+ *     analyticsBinding,
+ *   },
+ *   publishers: { orderCreated: orderCreatedEvent.publisher },
+ *   consumers: {
+ *     processOrder: processConsumer,
+ *     trackOrder: analyticsConsumer,
+ *   },
+ * });
+ * ```
+ */
+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>, {
+  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+}>>;
+/**
+ * Consumer-first builder result.
+ *
+ * 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.
+ *
+ * @template TMessage - The message definition
+ * @template TConsumer - The consumer definition
+ * @template TBinding - The queue binding definition
+ */
+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: () => PublisherDefinition<TMessage>;
+};
+/**
+ * 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
+ *
+ * Use this when you want to start with a consumer and ensure publishers
+ * send messages of the correct type.
+ *
+ * @param queue - The queue to consume from
+ * @param exchange - The exchange that routes to the queue (fanout type)
+ * @param message - The message definition (schema and metadata)
+ * @param options - Optional binding configuration
+ * @returns A consumer-first result with consumer, binding, and publisher factory
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const notificationsQueue = defineQueue('notifications', { durable: true });
+ * const notificationsExchange = defineExchange('notifications', 'fanout', { durable: true });
+ * const notificationMessage = defineMessage(
+ *   z.object({
+ *     userId: z.string(),
+ *     message: z.string(),
+ *   })
+ * );
+ *
+ * // Create consumer-first relationship
+ * const notificationConsumerFirst = defineConsumerFirst(
+ *   notificationsQueue,
+ *   notificationsExchange,
+ *   notificationMessage
+ * );
+ *
+ * // Use in contract
+ * const contract = defineContract({
+ *   exchanges: { notifications: notificationsExchange },
+ *   queues: { notificationsQueue },
+ *   bindings: { notificationBinding: notificationConsumerFirst.binding },
+ *   publishers: { sendNotification: notificationConsumerFirst.createPublisher() },
+ *   consumers: { processNotification: notificationConsumerFirst.consumer },
+ * });
+ * ```
+ */
+declare function defineConsumerFirst<TMessage extends MessageDefinition>(queue: QueueDefinition, exchange: FanoutExchangeDefinition, message: TMessage, options?: Omit<Extract<QueueBindingDefinition, {
+  exchange: FanoutExchangeDefinition;
+}>, "type" | "queue" | "exchange" | "routingKey">): ConsumerFirstResult<TMessage, ConsumerDefinition<TMessage>, Extract<QueueBindingDefinition, {
+  exchange: FanoutExchangeDefinition;
+}>>;
+/**
+ * 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
+ *
+ * Use this when you want to start with a consumer and ensure publishers
+ * 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 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
+ *
+ * @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 taskConsumerFirst = defineConsumerFirst(
+ *   taskQueue,
+ *   tasksExchange,
+ *   taskMessage,
+ *   { routingKey: 'task.execute' }
+ * );
+ *
+ * // Use in contract - routing key is consistent across consumer and publisher
+ * const contract = defineContract({
+ *   exchanges: { tasks: tasksExchange },
+ *   queues: { taskQueue },
+ *   bindings: { taskBinding: taskConsumerFirst.binding },
+ *   publishers: { executeTask: taskConsumerFirst.createPublisher() },
+ *   consumers: { processTask: taskConsumerFirst.consumer },
+ * });
+ * ```
+ */
+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;
+}>>;
 //#endregion
-export { type AnySchema, type BaseExchangeDefinition, type BindingDefinition, type ConsumerDefinition, type ContractDefinition, type DirectExchangeDefinition, type ExchangeBindingDefinition, type ExchangeDefinition, type FanoutExchangeDefinition, type InferConsumerNames, type InferPublisherNames, type MessageDefinition, type PublisherDefinition, type QueueBindingDefinition, type QueueDefinition, type TopicExchangeDefinition, defineConsumer, defineContract, defineExchange, defineExchangeBinding, defineMessage, definePublisher, defineQueue, defineQueueBinding };
+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 };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

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

package/dist/index.mjs

@@ -286,7 +286,59 @@ function defineConsumer(queue, message, options) {
 function defineContract(definition) {
 	return definition;
 }
+/**
+* Helper to call definePublisher with proper type handling.
+* Type safety is enforced by overloaded public function signatures.
+* @internal
+*/
+function callDefinePublisher(exchange, message, options) {
+	if (exchange.type === "fanout") return definePublisher(exchange, message, options);
+	return definePublisher(exchange, message, options);
+}
+/**
+* Helper to call defineQueueBinding with proper type handling.
+* Type safety is enforced by overloaded public function signatures.
+* @internal
+*/
+function callDefineQueueBinding(queue, exchange, options) {
+	if (exchange.type === "fanout") return defineQueueBinding(queue, exchange, options);
+	return defineQueueBinding(queue, exchange, options);
+}
+/**
+* Implementation of definePublisherFirst.
+* @internal
+*/
+function definePublisherFirst(exchange, message, options) {
+	const publisher = callDefinePublisher(exchange, message, options);
+	const createConsumer = (queue) => {
+		const binding = callDefineQueueBinding(queue, exchange, options);
+		return {
+			consumer: defineConsumer(queue, message),
+			binding
+		};
+	};
+	return {
+		publisher,
+		createConsumer
+	};
+}
+/**
+* Implementation of defineConsumerFirst.
+* @internal
+*/
+function defineConsumerFirst(queue, exchange, message, options) {
+	const consumer = defineConsumer(queue, message);
+	const binding = callDefineQueueBinding(queue, exchange, options);
+	const createPublisher = () => {
+		return callDefinePublisher(exchange, message, options);
+	};
+	return {
+		consumer,
+		binding,
+		createPublisher
+	};
+}
 
 //#endregion
-export { defineConsumer, defineContract, defineExchange, defineExchangeBinding, defineMessage, definePublisher, defineQueue, defineQueueBinding };
+export { defineConsumer, defineConsumerFirst, defineContract, defineExchange, defineExchangeBinding, defineMessage, definePublisher, definePublisherFirst, defineQueue, defineQueueBinding };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/builder.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type {\n  QueueBindingDefinition,\n  ExchangeBindingDefinition,\n  ConsumerDefinition,\n  ContractDefinition,\n  ExchangeDefinition,\n  PublisherDefinition,\n  QueueDefinition,\n  MessageDefinition,\n  FanoutExchangeDefinition,\n  TopicExchangeDefinition,\n  DirectExchangeDefinition,\n  BaseExchangeDefinition,\n} from \"./types.js\";\n\n/**\n * Define a fanout exchange.\n *\n * A fanout exchange routes messages to all bound queues without considering routing keys.\n * This exchange type is ideal for broadcasting messages to multiple consumers.\n *\n * @param name - The name of the exchange\n * @param type - Must be \"fanout\"\n * @param options - Optional exchange configuration\n * @param options.durable - If true, the exchange survives broker restarts (default: false)\n * @param options.autoDelete - If true, the exchange is deleted when no queues are bound (default: false)\n * @param options.internal - If true, the exchange cannot be directly published to (default: false)\n * @param options.arguments - Additional AMQP arguments for the exchange\n * @returns A fanout exchange definition\n *\n * @example\n * ```typescript\n * const logsExchange = defineExchange('logs', 'fanout', {\n *   durable: true\n * });\n * ```\n */\nexport function defineExchange(\n  name: string,\n  type: \"fanout\",\n  options?: Omit<BaseExchangeDefinition, \"name\" | \"type\">,\n): FanoutExchangeDefinition;\n\n/**\n * Define a direct exchange.\n *\n * A direct exchange routes messages to queues based on exact routing key matches.\n * This exchange type is ideal for point-to-point messaging.\n *\n * @param name - The name of the exchange\n * @param type - Must be \"direct\"\n * @param options - Optional exchange configuration\n * @param options.durable - If true, the exchange survives broker restarts (default: false)\n * @param options.autoDelete - If true, the exchange is deleted when no queues are bound (default: false)\n * @param options.internal - If true, the exchange cannot be directly published to (default: false)\n * @param options.arguments - Additional AMQP arguments for the exchange\n * @returns A direct exchange definition\n *\n * @example\n * ```typescript\n * const tasksExchange = defineExchange('tasks', 'direct', {\n *   durable: true\n * });\n * ```\n */\nexport function defineExchange(\n  name: string,\n  type: \"direct\",\n  options?: Omit<BaseExchangeDefinition, \"name\" | \"type\">,\n): DirectExchangeDefinition;\n\n/**\n * Define a topic exchange.\n *\n * A topic exchange routes messages to queues based on routing key patterns.\n * Routing keys can use wildcards: `*` matches one word, `#` matches zero or more words.\n * This exchange type is ideal for flexible message routing based on hierarchical topics.\n *\n * @param name - The name of the exchange\n * @param type - Must be \"topic\"\n * @param options - Optional exchange configuration\n * @param options.durable - If true, the exchange survives broker restarts (default: false)\n * @param options.autoDelete - If true, the exchange is deleted when no queues are bound (default: false)\n * @param options.internal - If true, the exchange cannot be directly published to (default: false)\n * @param options.arguments - Additional AMQP arguments for the exchange\n * @returns A topic exchange definition\n *\n * @example\n * ```typescript\n * const ordersExchange = defineExchange('orders', 'topic', {\n *   durable: true\n * });\n * ```\n */\nexport function defineExchange(\n  name: string,\n  type: \"topic\",\n  options?: Omit<BaseExchangeDefinition, \"name\" | \"type\">,\n): TopicExchangeDefinition;\n\n/**\n * Define an AMQP exchange.\n *\n * An exchange receives messages from publishers and routes them to queues based on the exchange type\n * and routing rules. This is the implementation function - use the type-specific overloads for better\n * type safety.\n *\n * @param name - The name of the exchange\n * @param type - The type of exchange: \"fanout\", \"direct\", or \"topic\"\n * @param options - Optional exchange configuration\n * @returns An exchange definition\n * @internal\n */\nexport function defineExchange(\n  name: string,\n  type: \"fanout\" | \"direct\" | \"topic\",\n  options?: Omit<BaseExchangeDefinition, \"name\" | \"type\">,\n): ExchangeDefinition {\n  return {\n    name,\n    type,\n    ...options,\n  };\n}\n\n/**\n * Define an AMQP queue.\n *\n * A queue stores messages until they are consumed by workers. Queues can be bound to exchanges\n * to receive messages based on routing rules.\n *\n * @param name - The name of the queue\n * @param options - Optional queue configuration\n * @param options.durable - If true, the queue survives broker restarts (default: false)\n * @param options.exclusive - If true, the queue can only be used by the declaring connection (default: false)\n * @param options.autoDelete - If true, the queue is deleted when the last consumer unsubscribes (default: false)\n * @param options.arguments - Additional AMQP arguments (e.g., x-message-ttl, x-dead-letter-exchange)\n * @returns A queue definition\n *\n * @example\n * ```typescript\n * const orderProcessingQueue = defineQueue('order-processing', {\n *   durable: true,\n *   arguments: {\n *     'x-message-ttl': 86400000, // 24 hours\n *     'x-dead-letter-exchange': 'orders-dlx'\n *   }\n * });\n * ```\n */\nexport function defineQueue(\n  name: string,\n  options?: Omit<QueueDefinition, \"name\">,\n): QueueDefinition {\n  return {\n    name,\n    ...options,\n  };\n}\n\n/**\n * Define a message definition with payload and optional headers/metadata.\n *\n * A message definition specifies the schema for message payloads and headers using\n * Standard Schema v1 compatible libraries (Zod, Valibot, ArkType, etc.).\n * The schemas are used for automatic validation when publishing or consuming messages.\n *\n * @param payload - The payload schema (must be Standard Schema v1 compatible)\n * @param options - Optional message metadata\n * @param options.headers - Optional header schema for message headers\n * @param options.summary - Brief description for documentation (used in AsyncAPI generation)\n * @param options.description - Detailed description for documentation (used in AsyncAPI generation)\n * @returns A message definition with inferred types\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const orderMessage = defineMessage(\n *   z.object({\n *     orderId: z.string().uuid(),\n *     customerId: z.string().uuid(),\n *     amount: z.number().positive(),\n *     items: z.array(z.object({\n *       productId: z.string(),\n *       quantity: z.number().int().positive(),\n *     })),\n *   }),\n *   {\n *     summary: 'Order created event',\n *     description: 'Emitted when a new order is created in the system'\n *   }\n * );\n * ```\n */\nexport function defineMessage<\n  TPayload extends MessageDefinition[\"payload\"],\n  THeaders extends StandardSchemaV1<Record<string, unknown>> | undefined = undefined,\n>(\n  payload: TPayload,\n  options?: {\n    headers?: THeaders;\n    summary?: string;\n    description?: string;\n  },\n): MessageDefinition<TPayload, THeaders> {\n  return {\n    payload,\n    ...options,\n  };\n}\n\n/**\n * Define a binding between a queue and a fanout exchange.\n *\n * Binds a queue to a fanout exchange to receive all messages published to the exchange.\n * Fanout exchanges ignore routing keys, so this overload doesn't require one.\n *\n * @param queue - The queue definition to bind\n * @param exchange - The fanout exchange definition\n * @param options - Optional binding configuration\n * @param options.arguments - Additional AMQP arguments for the binding\n * @returns A queue binding definition\n *\n * @example\n * ```typescript\n * const logsQueue = defineQueue('logs-queue', { durable: true });\n * const logsExchange = defineExchange('logs', 'fanout', { durable: true });\n *\n * const binding = defineQueueBinding(logsQueue, logsExchange);\n * ```\n */\nexport function defineQueueBinding(\n  queue: QueueDefinition,\n  exchange: FanoutExchangeDefinition,\n  options?: Omit<\n    Extract<QueueBindingDefinition, { exchange: FanoutExchangeDefinition }>,\n    \"type\" | \"queue\" | \"exchange\" | \"routingKey\"\n  >,\n): Extract<QueueBindingDefinition, { exchange: FanoutExchangeDefinition }>;\n\n/**\n * Define a binding between a queue and a direct or topic exchange.\n *\n * Binds a queue to an exchange with a specific routing key pattern.\n * Messages are only routed to the queue if the routing key matches the pattern.\n *\n * For direct exchanges: The routing key must match exactly.\n * For topic exchanges: The routing key can include wildcards:\n * - `*` matches exactly one word\n * - `#` matches zero or more words\n *\n * @param queue - The queue definition to bind\n * @param exchange - The direct or topic exchange definition\n * @param options - Binding configuration (routingKey is required)\n * @param options.routingKey - The routing key pattern for message routing\n * @param options.arguments - Additional AMQP arguments for the binding\n * @returns A queue binding definition\n *\n * @example\n * ```typescript\n * const orderQueue = defineQueue('order-processing', { durable: true });\n * const ordersExchange = defineExchange('orders', 'topic', { durable: true });\n *\n * // Bind with exact routing key\n * const binding = defineQueueBinding(orderQueue, ordersExchange, {\n *   routingKey: 'order.created'\n * });\n *\n * // Bind with wildcard pattern\n * const allOrdersBinding = defineQueueBinding(orderQueue, ordersExchange, {\n *   routingKey: 'order.*'  // Matches order.created, order.updated, etc.\n * });\n * ```\n */\nexport function defineQueueBinding(\n  queue: QueueDefinition,\n  exchange: DirectExchangeDefinition | TopicExchangeDefinition,\n  options: Omit<\n    Extract<\n      QueueBindingDefinition,\n      { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n    >,\n    \"type\" | \"queue\" | \"exchange\"\n  >,\n): Extract<\n  QueueBindingDefinition,\n  { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n>;\n\n/**\n * Define a binding between a queue and an exchange.\n *\n * This is the implementation function - use the type-specific overloads for better type safety.\n *\n * @param queue - The queue definition to bind\n * @param exchange - The exchange definition\n * @param options - Optional binding configuration\n * @returns A queue binding definition\n * @internal\n */\nexport function defineQueueBinding(\n  queue: QueueDefinition,\n  exchange: ExchangeDefinition,\n  options?: {\n    routingKey?: string;\n    arguments?: Record<string, unknown>;\n  },\n): QueueBindingDefinition {\n  if (exchange.type === \"fanout\") {\n    return {\n      type: \"queue\",\n      queue,\n      exchange,\n      ...(options?.arguments && { arguments: options.arguments }),\n    } as QueueBindingDefinition;\n  }\n\n  return {\n    type: \"queue\",\n    queue,\n    exchange,\n    routingKey: options?.routingKey,\n    ...(options?.arguments && { arguments: options.arguments }),\n  } as QueueBindingDefinition;\n}\n\n/**\n * Define a binding between two exchanges (exchange-to-exchange routing).\n *\n * Binds a destination exchange to a fanout source exchange.\n * Messages published to the source exchange will be forwarded to the destination exchange.\n * Fanout exchanges ignore routing keys, so this overload doesn't require one.\n *\n * @param destination - The destination exchange definition\n * @param source - The fanout source exchange definition\n * @param options - Optional binding configuration\n * @param options.arguments - Additional AMQP arguments for the binding\n * @returns An exchange binding definition\n *\n * @example\n * ```typescript\n * const sourceExchange = defineExchange('logs', 'fanout', { durable: true });\n * const destExchange = defineExchange('all-logs', 'fanout', { durable: true });\n *\n * const binding = defineExchangeBinding(destExchange, sourceExchange);\n * ```\n */\nexport function defineExchangeBinding(\n  destination: ExchangeDefinition,\n  source: FanoutExchangeDefinition,\n  options?: Omit<\n    Extract<ExchangeBindingDefinition, { source: FanoutExchangeDefinition }>,\n    \"type\" | \"source\" | \"destination\" | \"routingKey\"\n  >,\n): Extract<ExchangeBindingDefinition, { source: FanoutExchangeDefinition }>;\n\n/**\n * Define a binding between two exchanges (exchange-to-exchange routing).\n *\n * Binds a destination exchange to a direct or topic source exchange with a routing key pattern.\n * Messages are forwarded from source to destination only if the routing key matches the pattern.\n *\n * @param destination - The destination exchange definition\n * @param source - The direct or topic source exchange definition\n * @param options - Binding configuration (routingKey is required)\n * @param options.routingKey - The routing key pattern for message routing\n * @param options.arguments - Additional AMQP arguments for the binding\n * @returns An exchange binding definition\n *\n * @example\n * ```typescript\n * const ordersExchange = defineExchange('orders', 'topic', { durable: true });\n * const importantExchange = defineExchange('important-orders', 'topic', { durable: true });\n *\n * // Forward only high-value orders\n * const binding = defineExchangeBinding(importantExchange, ordersExchange, {\n *   routingKey: 'order.high-value.*'\n * });\n * ```\n */\nexport function defineExchangeBinding(\n  destination: ExchangeDefinition,\n  source: DirectExchangeDefinition | TopicExchangeDefinition,\n  options: Omit<\n    Extract<\n      ExchangeBindingDefinition,\n      { source: DirectExchangeDefinition | TopicExchangeDefinition }\n    >,\n    \"type\" | \"source\" | \"destination\"\n  >,\n): Extract<\n  ExchangeBindingDefinition,\n  { source: DirectExchangeDefinition | TopicExchangeDefinition }\n>;\n\n/**\n * Define a binding between two exchanges (exchange-to-exchange routing).\n *\n * This is the implementation function - use the type-specific overloads for better type safety.\n *\n * @param destination - The destination exchange definition\n * @param source - The source exchange definition\n * @param options - Optional binding configuration\n * @returns An exchange binding definition\n * @internal\n */\nexport function defineExchangeBinding(\n  destination: ExchangeDefinition,\n  source: ExchangeDefinition,\n  options?: {\n    routingKey?: string;\n    arguments?: Record<string, unknown>;\n  },\n): ExchangeBindingDefinition {\n  if (source.type === \"fanout\") {\n    return {\n      type: \"exchange\",\n      source,\n      destination,\n      ...(options?.arguments && { arguments: options.arguments }),\n    } as ExchangeBindingDefinition;\n  }\n\n  return {\n    type: \"exchange\",\n    source,\n    destination,\n    routingKey: options?.routingKey ?? \"\",\n    ...(options?.arguments && { arguments: options.arguments }),\n  } as ExchangeBindingDefinition;\n}\n\n/**\n * Define a message publisher for a fanout exchange.\n *\n * A publisher sends messages to an exchange. For fanout exchanges, messages are broadcast\n * to all bound queues regardless of routing key, so no routing key is required.\n *\n * The message schema is validated when publishing to ensure type safety.\n *\n * @param exchange - The fanout exchange definition to publish to\n * @param message - The message definition with payload schema\n * @param options - Optional publisher configuration\n * @returns A publisher definition with inferred message types\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const logsExchange = defineExchange('logs', 'fanout', { durable: true });\n * const logMessage = defineMessage(\n *   z.object({\n *     level: z.enum(['info', 'warn', 'error']),\n *     message: z.string(),\n *     timestamp: z.string().datetime(),\n *   })\n * );\n *\n * const logPublisher = definePublisher(logsExchange, logMessage);\n * ```\n */\nexport function definePublisher<TMessage extends MessageDefinition>(\n  exchange: FanoutExchangeDefinition,\n  message: TMessage,\n  options?: Omit<\n    Extract<PublisherDefinition<TMessage>, { exchange: FanoutExchangeDefinition }>,\n    \"exchange\" | \"message\" | \"routingKey\"\n  >,\n): Extract<PublisherDefinition<TMessage>, { exchange: FanoutExchangeDefinition }>;\n\n/**\n * Define a message publisher for a direct or topic exchange.\n *\n * A publisher sends messages to an exchange with a specific routing key.\n * The routing key determines which queues receive the message.\n *\n * The message schema is validated when publishing to ensure type safety.\n *\n * @param exchange - The direct or topic exchange definition to publish to\n * @param message - The message definition with payload schema\n * @param options - Publisher configuration (routingKey is required)\n * @param options.routingKey - The routing key for message routing\n * @returns A publisher definition with inferred message types\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const ordersExchange = defineExchange('orders', 'topic', { durable: true });\n * const orderMessage = defineMessage(\n *   z.object({\n *     orderId: z.string().uuid(),\n *     amount: z.number().positive(),\n *   }),\n *   {\n *     summary: 'Order created event',\n *     description: 'Emitted when a new order is created'\n *   }\n * );\n *\n * const orderCreatedPublisher = definePublisher(ordersExchange, orderMessage, {\n *   routingKey: 'order.created'\n * });\n * ```\n */\nexport function definePublisher<TMessage extends MessageDefinition>(\n  exchange: DirectExchangeDefinition | TopicExchangeDefinition,\n  message: TMessage,\n  options: Omit<\n    Extract<\n      PublisherDefinition<TMessage>,\n      { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n    >,\n    \"exchange\" | \"message\"\n  >,\n): Extract<\n  PublisherDefinition<TMessage>,\n  { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n>;\n\n/**\n * Define a message publisher.\n *\n * This is the implementation function - use the type-specific overloads for better type safety.\n *\n * @param exchange - The exchange definition\n * @param message - The message definition\n * @param options - Optional publisher configuration\n * @returns A publisher definition\n * @internal\n */\nexport function definePublisher<TMessage extends MessageDefinition>(\n  exchange: ExchangeDefinition,\n  message: TMessage,\n  options?: { routingKey?: string },\n): PublisherDefinition<TMessage> {\n  if (exchange.type === \"fanout\") {\n    return {\n      exchange,\n      message,\n    } as PublisherDefinition<TMessage>;\n  }\n\n  return {\n    exchange,\n    message,\n    routingKey: options?.routingKey ?? \"\",\n  } as PublisherDefinition<TMessage>;\n}\n\n/**\n * Define a message consumer.\n *\n * A consumer receives and processes messages from a queue. The message schema is validated\n * automatically when messages are consumed, ensuring type safety for your handlers.\n *\n * Consumers are associated with a specific queue and message type. When you create a worker\n * with this consumer, it will process messages from the queue according to the schema.\n *\n * @param queue - The queue definition to consume from\n * @param message - The message definition with payload schema\n * @param options - Optional consumer configuration\n * @returns A consumer definition with inferred message types\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const orderQueue = defineQueue('order-processing', { durable: true });\n * const orderMessage = defineMessage(\n *   z.object({\n *     orderId: z.string().uuid(),\n *     customerId: z.string().uuid(),\n *     amount: z.number().positive(),\n *   })\n * );\n *\n * const processOrderConsumer = defineConsumer(orderQueue, orderMessage);\n *\n * // Later, when creating a worker, you'll provide a handler for this consumer:\n * // const worker = await TypedAmqpWorker.create({\n * //   contract,\n * //   handlers: {\n * //     processOrder: async (message) => {\n * //       // message is automatically typed based on the schema\n * //       console.log(message.orderId); // string\n * //     }\n * //   },\n * //   connection\n * // });\n * ```\n */\nexport function defineConsumer<TMessage extends MessageDefinition>(\n  queue: QueueDefinition,\n  message: TMessage,\n  options?: Omit<ConsumerDefinition<TMessage>, \"queue\" | \"message\">,\n): ConsumerDefinition<TMessage> {\n  return {\n    queue,\n    message,\n    ...options,\n  };\n}\n\n/**\n * Define an AMQP contract.\n *\n * A contract is the central definition of your AMQP messaging topology. It brings together\n * all exchanges, queues, bindings, publishers, and consumers in a single, type-safe definition.\n *\n * The contract is used by both clients (for publishing) and workers (for consuming) to ensure\n * type safety throughout your messaging infrastructure. TypeScript will infer all message types\n * and publisher/consumer names from the contract.\n *\n * @param definition - The contract definition containing all AMQP resources\n * @param definition.exchanges - Named exchange definitions\n * @param definition.queues - Named queue definitions\n * @param definition.bindings - Named binding definitions (queue-to-exchange or exchange-to-exchange)\n * @param definition.publishers - Named publisher definitions for sending messages\n * @param definition.consumers - Named consumer definitions for receiving messages\n * @returns The same contract definition with full type inference\n *\n * @example\n * ```typescript\n * import {\n *   defineContract,\n *   defineExchange,\n *   defineQueue,\n *   defineQueueBinding,\n *   definePublisher,\n *   defineConsumer,\n *   defineMessage,\n * } from '@amqp-contract/contract';\n * import { z } from 'zod';\n *\n * // Define resources\n * const ordersExchange = defineExchange('orders', 'topic', { durable: true });\n * const orderQueue = defineQueue('order-processing', { durable: true });\n * const orderMessage = defineMessage(\n *   z.object({\n *     orderId: z.string(),\n *     amount: z.number(),\n *   })\n * );\n *\n * // Compose contract\n * export const contract = defineContract({\n *   exchanges: {\n *     orders: ordersExchange,\n *   },\n *   queues: {\n *     orderProcessing: orderQueue,\n *   },\n *   bindings: {\n *     orderBinding: defineQueueBinding(orderQueue, ordersExchange, {\n *       routingKey: 'order.created',\n *     }),\n *   },\n *   publishers: {\n *     orderCreated: definePublisher(ordersExchange, orderMessage, {\n *       routingKey: 'order.created',\n *     }),\n *   },\n *   consumers: {\n *     processOrder: defineConsumer(orderQueue, orderMessage),\n *   },\n * });\n *\n * // TypeScript now knows:\n * // - client.publish('orderCreated', { orderId: string, amount: number })\n * // - handler: async (message: { orderId: string, amount: number }) => void\n * ```\n */\nexport function defineContract<TContract extends ContractDefinition>(\n  definition: TContract,\n): TContract {\n  return definition;\n}\n"],"mappings":";;;;;;;;;;;;;;AAkHA,SAAgB,eACd,MACA,MACA,SACoB;AACpB,QAAO;EACL;EACA;EACA,GAAG;EACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BH,SAAgB,YACd,MACA,SACiB;AACjB,QAAO;EACL;EACA,GAAG;EACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCH,SAAgB,cAId,SACA,SAKuC;AACvC,QAAO;EACL;EACA,GAAG;EACJ;;;;;;;;;;;;;AA4FH,SAAgB,mBACd,OACA,UACA,SAIwB;AACxB,KAAI,SAAS,SAAS,SACpB,QAAO;EACL,MAAM;EACN;EACA;EACA,GAAI,SAAS,aAAa,EAAE,WAAW,QAAQ,WAAW;EAC3D;AAGH,QAAO;EACL,MAAM;EACN;EACA;EACA,YAAY,SAAS;EACrB,GAAI,SAAS,aAAa,EAAE,WAAW,QAAQ,WAAW;EAC3D;;;;;;;;;;;;;AAmFH,SAAgB,sBACd,aACA,QACA,SAI2B;AAC3B,KAAI,OAAO,SAAS,SAClB,QAAO;EACL,MAAM;EACN;EACA;EACA,GAAI,SAAS,aAAa,EAAE,WAAW,QAAQ,WAAW;EAC3D;AAGH,QAAO;EACL,MAAM;EACN;EACA;EACA,YAAY,SAAS,cAAc;EACnC,GAAI,SAAS,aAAa,EAAE,WAAW,QAAQ,WAAW;EAC3D;;;;;;;;;;;;;AAsGH,SAAgB,gBACd,UACA,SACA,SAC+B;AAC/B,KAAI,SAAS,SAAS,SACpB,QAAO;EACL;EACA;EACD;AAGH,QAAO;EACL;EACA;EACA,YAAY,SAAS,cAAc;EACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CH,SAAgB,eACd,OACA,SACA,SAC8B;AAC9B,QAAO;EACL;EACA;EACA,GAAG;EACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEH,SAAgB,eACd,YACW;AACX,QAAO"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/builder.ts"],"sourcesContent":["import type {\n  BaseExchangeDefinition,\n  ConsumerDefinition,\n  ContractDefinition,\n  DirectExchangeDefinition,\n  ExchangeBindingDefinition,\n  ExchangeDefinition,\n  FanoutExchangeDefinition,\n  MessageDefinition,\n  PublisherDefinition,\n  QueueBindingDefinition,\n  QueueDefinition,\n  TopicExchangeDefinition,\n} from \"./types.js\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * Define a fanout exchange.\n *\n * A fanout exchange routes messages to all bound queues without considering routing keys.\n * This exchange type is ideal for broadcasting messages to multiple consumers.\n *\n * @param name - The name of the exchange\n * @param type - Must be \"fanout\"\n * @param options - Optional exchange configuration\n * @param options.durable - If true, the exchange survives broker restarts (default: false)\n * @param options.autoDelete - If true, the exchange is deleted when no queues are bound (default: false)\n * @param options.internal - If true, the exchange cannot be directly published to (default: false)\n * @param options.arguments - Additional AMQP arguments for the exchange\n * @returns A fanout exchange definition\n *\n * @example\n * ```typescript\n * const logsExchange = defineExchange('logs', 'fanout', {\n *   durable: true\n * });\n * ```\n */\nexport function defineExchange(\n  name: string,\n  type: \"fanout\",\n  options?: Omit<BaseExchangeDefinition, \"name\" | \"type\">,\n): FanoutExchangeDefinition;\n\n/**\n * Define a direct exchange.\n *\n * A direct exchange routes messages to queues based on exact routing key matches.\n * This exchange type is ideal for point-to-point messaging.\n *\n * @param name - The name of the exchange\n * @param type - Must be \"direct\"\n * @param options - Optional exchange configuration\n * @param options.durable - If true, the exchange survives broker restarts (default: false)\n * @param options.autoDelete - If true, the exchange is deleted when no queues are bound (default: false)\n * @param options.internal - If true, the exchange cannot be directly published to (default: false)\n * @param options.arguments - Additional AMQP arguments for the exchange\n * @returns A direct exchange definition\n *\n * @example\n * ```typescript\n * const tasksExchange = defineExchange('tasks', 'direct', {\n *   durable: true\n * });\n * ```\n */\nexport function defineExchange(\n  name: string,\n  type: \"direct\",\n  options?: Omit<BaseExchangeDefinition, \"name\" | \"type\">,\n): DirectExchangeDefinition;\n\n/**\n * Define a topic exchange.\n *\n * A topic exchange routes messages to queues based on routing key patterns.\n * Routing keys can use wildcards: `*` matches one word, `#` matches zero or more words.\n * This exchange type is ideal for flexible message routing based on hierarchical topics.\n *\n * @param name - The name of the exchange\n * @param type - Must be \"topic\"\n * @param options - Optional exchange configuration\n * @param options.durable - If true, the exchange survives broker restarts (default: false)\n * @param options.autoDelete - If true, the exchange is deleted when no queues are bound (default: false)\n * @param options.internal - If true, the exchange cannot be directly published to (default: false)\n * @param options.arguments - Additional AMQP arguments for the exchange\n * @returns A topic exchange definition\n *\n * @example\n * ```typescript\n * const ordersExchange = defineExchange('orders', 'topic', {\n *   durable: true\n * });\n * ```\n */\nexport function defineExchange(\n  name: string,\n  type: \"topic\",\n  options?: Omit<BaseExchangeDefinition, \"name\" | \"type\">,\n): TopicExchangeDefinition;\n\n/**\n * Define an AMQP exchange.\n *\n * An exchange receives messages from publishers and routes them to queues based on the exchange type\n * and routing rules. This is the implementation function - use the type-specific overloads for better\n * type safety.\n *\n * @param name - The name of the exchange\n * @param type - The type of exchange: \"fanout\", \"direct\", or \"topic\"\n * @param options - Optional exchange configuration\n * @returns An exchange definition\n * @internal\n */\nexport function defineExchange(\n  name: string,\n  type: \"fanout\" | \"direct\" | \"topic\",\n  options?: Omit<BaseExchangeDefinition, \"name\" | \"type\">,\n): ExchangeDefinition {\n  return {\n    name,\n    type,\n    ...options,\n  };\n}\n\n/**\n * Define an AMQP queue.\n *\n * A queue stores messages until they are consumed by workers. Queues can be bound to exchanges\n * to receive messages based on routing rules.\n *\n * @param name - The name of the queue\n * @param options - Optional queue configuration\n * @param options.durable - If true, the queue survives broker restarts (default: false)\n * @param options.exclusive - If true, the queue can only be used by the declaring connection (default: false)\n * @param options.autoDelete - If true, the queue is deleted when the last consumer unsubscribes (default: false)\n * @param options.arguments - Additional AMQP arguments (e.g., x-message-ttl, x-dead-letter-exchange)\n * @returns A queue definition\n *\n * @example\n * ```typescript\n * const orderProcessingQueue = defineQueue('order-processing', {\n *   durable: true,\n *   arguments: {\n *     'x-message-ttl': 86400000, // 24 hours\n *     'x-dead-letter-exchange': 'orders-dlx'\n *   }\n * });\n * ```\n */\nexport function defineQueue(\n  name: string,\n  options?: Omit<QueueDefinition, \"name\">,\n): QueueDefinition {\n  return {\n    name,\n    ...options,\n  };\n}\n\n/**\n * Define a message definition with payload and optional headers/metadata.\n *\n * A message definition specifies the schema for message payloads and headers using\n * Standard Schema v1 compatible libraries (Zod, Valibot, ArkType, etc.).\n * The schemas are used for automatic validation when publishing or consuming messages.\n *\n * @param payload - The payload schema (must be Standard Schema v1 compatible)\n * @param options - Optional message metadata\n * @param options.headers - Optional header schema for message headers\n * @param options.summary - Brief description for documentation (used in AsyncAPI generation)\n * @param options.description - Detailed description for documentation (used in AsyncAPI generation)\n * @returns A message definition with inferred types\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const orderMessage = defineMessage(\n *   z.object({\n *     orderId: z.string().uuid(),\n *     customerId: z.string().uuid(),\n *     amount: z.number().positive(),\n *     items: z.array(z.object({\n *       productId: z.string(),\n *       quantity: z.number().int().positive(),\n *     })),\n *   }),\n *   {\n *     summary: 'Order created event',\n *     description: 'Emitted when a new order is created in the system'\n *   }\n * );\n * ```\n */\nexport function defineMessage<\n  TPayload extends MessageDefinition[\"payload\"],\n  THeaders extends StandardSchemaV1<Record<string, unknown>> | undefined = undefined,\n>(\n  payload: TPayload,\n  options?: {\n    headers?: THeaders;\n    summary?: string;\n    description?: string;\n  },\n): MessageDefinition<TPayload, THeaders> {\n  return {\n    payload,\n    ...options,\n  };\n}\n\n/**\n * Define a binding between a queue and a fanout exchange.\n *\n * Binds a queue to a fanout exchange to receive all messages published to the exchange.\n * Fanout exchanges ignore routing keys, so this overload doesn't require one.\n *\n * @param queue - The queue definition to bind\n * @param exchange - The fanout exchange definition\n * @param options - Optional binding configuration\n * @param options.arguments - Additional AMQP arguments for the binding\n * @returns A queue binding definition\n *\n * @example\n * ```typescript\n * const logsQueue = defineQueue('logs-queue', { durable: true });\n * const logsExchange = defineExchange('logs', 'fanout', { durable: true });\n *\n * const binding = defineQueueBinding(logsQueue, logsExchange);\n * ```\n */\nexport function defineQueueBinding(\n  queue: QueueDefinition,\n  exchange: FanoutExchangeDefinition,\n  options?: Omit<\n    Extract<QueueBindingDefinition, { exchange: FanoutExchangeDefinition }>,\n    \"type\" | \"queue\" | \"exchange\" | \"routingKey\"\n  >,\n): Extract<QueueBindingDefinition, { exchange: FanoutExchangeDefinition }>;\n\n/**\n * Define a binding between a queue and a direct or topic exchange.\n *\n * Binds a queue to an exchange with a specific routing key pattern.\n * Messages are only routed to the queue if the routing key matches the pattern.\n *\n * For direct exchanges: The routing key must match exactly.\n * For topic exchanges: The routing key can include wildcards:\n * - `*` matches exactly one word\n * - `#` matches zero or more words\n *\n * @param queue - The queue definition to bind\n * @param exchange - The direct or topic exchange definition\n * @param options - Binding configuration (routingKey is required)\n * @param options.routingKey - The routing key pattern for message routing\n * @param options.arguments - Additional AMQP arguments for the binding\n * @returns A queue binding definition\n *\n * @example\n * ```typescript\n * const orderQueue = defineQueue('order-processing', { durable: true });\n * const ordersExchange = defineExchange('orders', 'topic', { durable: true });\n *\n * // Bind with exact routing key\n * const binding = defineQueueBinding(orderQueue, ordersExchange, {\n *   routingKey: 'order.created'\n * });\n *\n * // Bind with wildcard pattern\n * const allOrdersBinding = defineQueueBinding(orderQueue, ordersExchange, {\n *   routingKey: 'order.*'  // Matches order.created, order.updated, etc.\n * });\n * ```\n */\nexport function defineQueueBinding(\n  queue: QueueDefinition,\n  exchange: DirectExchangeDefinition | TopicExchangeDefinition,\n  options: Omit<\n    Extract<\n      QueueBindingDefinition,\n      { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n    >,\n    \"type\" | \"queue\" | \"exchange\"\n  >,\n): Extract<\n  QueueBindingDefinition,\n  { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n>;\n\n/**\n * Define a binding between a queue and an exchange.\n *\n * This is the implementation function - use the type-specific overloads for better type safety.\n *\n * @param queue - The queue definition to bind\n * @param exchange - The exchange definition\n * @param options - Optional binding configuration\n * @returns A queue binding definition\n * @internal\n */\nexport function defineQueueBinding(\n  queue: QueueDefinition,\n  exchange: ExchangeDefinition,\n  options?: {\n    routingKey?: string;\n    arguments?: Record<string, unknown>;\n  },\n): QueueBindingDefinition {\n  if (exchange.type === \"fanout\") {\n    return {\n      type: \"queue\",\n      queue,\n      exchange,\n      ...(options?.arguments && { arguments: options.arguments }),\n    } as QueueBindingDefinition;\n  }\n\n  return {\n    type: \"queue\",\n    queue,\n    exchange,\n    routingKey: options?.routingKey,\n    ...(options?.arguments && { arguments: options.arguments }),\n  } as QueueBindingDefinition;\n}\n\n/**\n * Define a binding between two exchanges (exchange-to-exchange routing).\n *\n * Binds a destination exchange to a fanout source exchange.\n * Messages published to the source exchange will be forwarded to the destination exchange.\n * Fanout exchanges ignore routing keys, so this overload doesn't require one.\n *\n * @param destination - The destination exchange definition\n * @param source - The fanout source exchange definition\n * @param options - Optional binding configuration\n * @param options.arguments - Additional AMQP arguments for the binding\n * @returns An exchange binding definition\n *\n * @example\n * ```typescript\n * const sourceExchange = defineExchange('logs', 'fanout', { durable: true });\n * const destExchange = defineExchange('all-logs', 'fanout', { durable: true });\n *\n * const binding = defineExchangeBinding(destExchange, sourceExchange);\n * ```\n */\nexport function defineExchangeBinding(\n  destination: ExchangeDefinition,\n  source: FanoutExchangeDefinition,\n  options?: Omit<\n    Extract<ExchangeBindingDefinition, { source: FanoutExchangeDefinition }>,\n    \"type\" | \"source\" | \"destination\" | \"routingKey\"\n  >,\n): Extract<ExchangeBindingDefinition, { source: FanoutExchangeDefinition }>;\n\n/**\n * Define a binding between two exchanges (exchange-to-exchange routing).\n *\n * Binds a destination exchange to a direct or topic source exchange with a routing key pattern.\n * Messages are forwarded from source to destination only if the routing key matches the pattern.\n *\n * @param destination - The destination exchange definition\n * @param source - The direct or topic source exchange definition\n * @param options - Binding configuration (routingKey is required)\n * @param options.routingKey - The routing key pattern for message routing\n * @param options.arguments - Additional AMQP arguments for the binding\n * @returns An exchange binding definition\n *\n * @example\n * ```typescript\n * const ordersExchange = defineExchange('orders', 'topic', { durable: true });\n * const importantExchange = defineExchange('important-orders', 'topic', { durable: true });\n *\n * // Forward only high-value orders\n * const binding = defineExchangeBinding(importantExchange, ordersExchange, {\n *   routingKey: 'order.high-value.*'\n * });\n * ```\n */\nexport function defineExchangeBinding(\n  destination: ExchangeDefinition,\n  source: DirectExchangeDefinition | TopicExchangeDefinition,\n  options: Omit<\n    Extract<\n      ExchangeBindingDefinition,\n      { source: DirectExchangeDefinition | TopicExchangeDefinition }\n    >,\n    \"type\" | \"source\" | \"destination\"\n  >,\n): Extract<\n  ExchangeBindingDefinition,\n  { source: DirectExchangeDefinition | TopicExchangeDefinition }\n>;\n\n/**\n * Define a binding between two exchanges (exchange-to-exchange routing).\n *\n * This is the implementation function - use the type-specific overloads for better type safety.\n *\n * @param destination - The destination exchange definition\n * @param source - The source exchange definition\n * @param options - Optional binding configuration\n * @returns An exchange binding definition\n * @internal\n */\nexport function defineExchangeBinding(\n  destination: ExchangeDefinition,\n  source: ExchangeDefinition,\n  options?: {\n    routingKey?: string;\n    arguments?: Record<string, unknown>;\n  },\n): ExchangeBindingDefinition {\n  if (source.type === \"fanout\") {\n    return {\n      type: \"exchange\",\n      source,\n      destination,\n      ...(options?.arguments && { arguments: options.arguments }),\n    } as ExchangeBindingDefinition;\n  }\n\n  return {\n    type: \"exchange\",\n    source,\n    destination,\n    routingKey: options?.routingKey ?? \"\",\n    ...(options?.arguments && { arguments: options.arguments }),\n  } as ExchangeBindingDefinition;\n}\n\n/**\n * Define a message publisher for a fanout exchange.\n *\n * A publisher sends messages to an exchange. For fanout exchanges, messages are broadcast\n * to all bound queues regardless of routing key, so no routing key is required.\n *\n * The message schema is validated when publishing to ensure type safety.\n *\n * @param exchange - The fanout exchange definition to publish to\n * @param message - The message definition with payload schema\n * @param options - Optional publisher configuration\n * @returns A publisher definition with inferred message types\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const logsExchange = defineExchange('logs', 'fanout', { durable: true });\n * const logMessage = defineMessage(\n *   z.object({\n *     level: z.enum(['info', 'warn', 'error']),\n *     message: z.string(),\n *     timestamp: z.string().datetime(),\n *   })\n * );\n *\n * const logPublisher = definePublisher(logsExchange, logMessage);\n * ```\n */\nexport function definePublisher<TMessage extends MessageDefinition>(\n  exchange: FanoutExchangeDefinition,\n  message: TMessage,\n  options?: Omit<\n    Extract<PublisherDefinition<TMessage>, { exchange: FanoutExchangeDefinition }>,\n    \"exchange\" | \"message\" | \"routingKey\"\n  >,\n): Extract<PublisherDefinition<TMessage>, { exchange: FanoutExchangeDefinition }>;\n\n/**\n * Define a message publisher for a direct or topic exchange.\n *\n * A publisher sends messages to an exchange with a specific routing key.\n * The routing key determines which queues receive the message.\n *\n * The message schema is validated when publishing to ensure type safety.\n *\n * @param exchange - The direct or topic exchange definition to publish to\n * @param message - The message definition with payload schema\n * @param options - Publisher configuration (routingKey is required)\n * @param options.routingKey - The routing key for message routing\n * @returns A publisher definition with inferred message types\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const ordersExchange = defineExchange('orders', 'topic', { durable: true });\n * const orderMessage = defineMessage(\n *   z.object({\n *     orderId: z.string().uuid(),\n *     amount: z.number().positive(),\n *   }),\n *   {\n *     summary: 'Order created event',\n *     description: 'Emitted when a new order is created'\n *   }\n * );\n *\n * const orderCreatedPublisher = definePublisher(ordersExchange, orderMessage, {\n *   routingKey: 'order.created'\n * });\n * ```\n */\nexport function definePublisher<TMessage extends MessageDefinition>(\n  exchange: DirectExchangeDefinition | TopicExchangeDefinition,\n  message: TMessage,\n  options: Omit<\n    Extract<\n      PublisherDefinition<TMessage>,\n      { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n    >,\n    \"exchange\" | \"message\"\n  >,\n): Extract<\n  PublisherDefinition<TMessage>,\n  { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n>;\n\n/**\n * Define a message publisher.\n *\n * This is the implementation function - use the type-specific overloads for better type safety.\n *\n * @param exchange - The exchange definition\n * @param message - The message definition\n * @param options - Optional publisher configuration\n * @returns A publisher definition\n * @internal\n */\nexport function definePublisher<TMessage extends MessageDefinition>(\n  exchange: ExchangeDefinition,\n  message: TMessage,\n  options?: { routingKey?: string },\n): PublisherDefinition<TMessage> {\n  if (exchange.type === \"fanout\") {\n    return {\n      exchange,\n      message,\n    } as PublisherDefinition<TMessage>;\n  }\n\n  return {\n    exchange,\n    message,\n    routingKey: options?.routingKey ?? \"\",\n  } as PublisherDefinition<TMessage>;\n}\n\n/**\n * Define a message consumer.\n *\n * A consumer receives and processes messages from a queue. The message schema is validated\n * automatically when messages are consumed, ensuring type safety for your handlers.\n *\n * Consumers are associated with a specific queue and message type. When you create a worker\n * with this consumer, it will process messages from the queue according to the schema.\n *\n * @param queue - The queue definition to consume from\n * @param message - The message definition with payload schema\n * @param options - Optional consumer configuration\n * @returns A consumer definition with inferred message types\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const orderQueue = defineQueue('order-processing', { durable: true });\n * const orderMessage = defineMessage(\n *   z.object({\n *     orderId: z.string().uuid(),\n *     customerId: z.string().uuid(),\n *     amount: z.number().positive(),\n *   })\n * );\n *\n * const processOrderConsumer = defineConsumer(orderQueue, orderMessage);\n *\n * // Later, when creating a worker, you'll provide a handler for this consumer:\n * // const worker = await TypedAmqpWorker.create({\n * //   contract,\n * //   handlers: {\n * //     processOrder: async (message) => {\n * //       // message is automatically typed based on the schema\n * //       console.log(message.orderId); // string\n * //     }\n * //   },\n * //   connection\n * // });\n * ```\n */\nexport function defineConsumer<TMessage extends MessageDefinition>(\n  queue: QueueDefinition,\n  message: TMessage,\n  options?: Omit<ConsumerDefinition<TMessage>, \"queue\" | \"message\">,\n): ConsumerDefinition<TMessage> {\n  return {\n    queue,\n    message,\n    ...options,\n  };\n}\n\n/**\n * Define an AMQP contract.\n *\n * A contract is the central definition of your AMQP messaging topology. It brings together\n * all exchanges, queues, bindings, publishers, and consumers in a single, type-safe definition.\n *\n * The contract is used by both clients (for publishing) and workers (for consuming) to ensure\n * type safety throughout your messaging infrastructure. TypeScript will infer all message types\n * and publisher/consumer names from the contract.\n *\n * @param definition - The contract definition containing all AMQP resources\n * @param definition.exchanges - Named exchange definitions\n * @param definition.queues - Named queue definitions\n * @param definition.bindings - Named binding definitions (queue-to-exchange or exchange-to-exchange)\n * @param definition.publishers - Named publisher definitions for sending messages\n * @param definition.consumers - Named consumer definitions for receiving messages\n * @returns The same contract definition with full type inference\n *\n * @example\n * ```typescript\n * import {\n *   defineContract,\n *   defineExchange,\n *   defineQueue,\n *   defineQueueBinding,\n *   definePublisher,\n *   defineConsumer,\n *   defineMessage,\n * } from '@amqp-contract/contract';\n * import { z } from 'zod';\n *\n * // Define resources\n * const ordersExchange = defineExchange('orders', 'topic', { durable: true });\n * const orderQueue = defineQueue('order-processing', { durable: true });\n * const orderMessage = defineMessage(\n *   z.object({\n *     orderId: z.string(),\n *     amount: z.number(),\n *   })\n * );\n *\n * // Compose contract\n * export const contract = defineContract({\n *   exchanges: {\n *     orders: ordersExchange,\n *   },\n *   queues: {\n *     orderProcessing: orderQueue,\n *   },\n *   bindings: {\n *     orderBinding: defineQueueBinding(orderQueue, ordersExchange, {\n *       routingKey: 'order.created',\n *     }),\n *   },\n *   publishers: {\n *     orderCreated: definePublisher(ordersExchange, orderMessage, {\n *       routingKey: 'order.created',\n *     }),\n *   },\n *   consumers: {\n *     processOrder: defineConsumer(orderQueue, orderMessage),\n *   },\n * });\n *\n * // TypeScript now knows:\n * // - client.publish('orderCreated', { orderId: string, amount: number })\n * // - handler: async (message: { orderId: string, amount: number }) => void\n * ```\n */\nexport function defineContract<TContract extends ContractDefinition>(\n  definition: TContract,\n): TContract {\n  return definition;\n}\n\n/**\n * Helper to call definePublisher with proper type handling.\n * Type safety is enforced by overloaded public function signatures.\n * @internal\n */\nfunction callDefinePublisher<TMessage extends MessageDefinition>(\n  exchange: ExchangeDefinition,\n  message: TMessage,\n  options?: {\n    routingKey?: string;\n    arguments?: Record<string, unknown>;\n  },\n): PublisherDefinition<TMessage> {\n  // Type assertion is safe because overloaded signatures enforce routingKey requirement\n  if (exchange.type === \"fanout\") {\n    return definePublisher(exchange, message, options);\n  }\n  return definePublisher(exchange, message, options as { routingKey: string });\n}\n\n/**\n * Helper to call defineQueueBinding with proper type handling.\n * Type safety is enforced by overloaded public function signatures.\n * @internal\n */\nfunction callDefineQueueBinding(\n  queue: QueueDefinition,\n  exchange: ExchangeDefinition,\n  options?: {\n    routingKey?: string;\n    arguments?: Record<string, unknown>;\n  },\n): QueueBindingDefinition {\n  // Type assertion is safe because overloaded signatures enforce routingKey requirement\n  if (exchange.type === \"fanout\") {\n    return defineQueueBinding(queue, exchange, options);\n  }\n  return defineQueueBinding(queue, exchange, options as { routingKey: string });\n}\n\n/**\n * Publisher-first builder result.\n *\n * This type represents a publisher and provides a method to create\n * a consumer that uses the same message schema with a binding to the exchange.\n *\n * This pattern is suitable for event-oriented messaging where publishers\n * emit events without knowing which queues will consume them.\n *\n * @template TMessage - The message definition\n * @template TPublisher - The publisher definition\n */\nexport type PublisherFirstResult<\n  TMessage extends MessageDefinition,\n  TPublisher extends PublisherDefinition<TMessage>,\n> = {\n  /** The publisher definition */\n  publisher: TPublisher;\n  /**\n   * Create a consumer that receives messages from this publisher.\n   * The consumer will automatically use the same message schema and\n   * a binding will be created with the same routing key.\n   *\n   * @param queue - The queue that will consume the messages\n   * @returns An object with the consumer definition and binding\n   */\n  createConsumer: (queue: QueueDefinition) => {\n    consumer: ConsumerDefinition<TMessage>;\n    binding: QueueBindingDefinition;\n  };\n};\n\n/**\n * Define a publisher-first relationship for event-oriented messaging.\n *\n * This builder enforces consistency by:\n * 1. Ensuring the publisher and consumer use the same message schema\n * 2. Linking the routing key from the publisher to the binding\n *\n * Use this pattern for events where publishers don't need to know about queues.\n * Multiple consumers can be created for different queues, all using the same message schema.\n *\n * @param exchange - The exchange to publish to (fanout type)\n * @param message - The message definition (schema and metadata)\n * @param options - Optional binding configuration\n * @returns A publisher-first result with publisher and consumer factory\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const logsExchange = defineExchange('logs', 'fanout', { durable: true });\n * const logMessage = defineMessage(\n *   z.object({\n *     level: z.enum(['info', 'warn', 'error']),\n *     message: z.string(),\n *   })\n * );\n *\n * // Create publisher-first relationship (event pattern)\n * const logEvent = definePublisherFirst(logsExchange, logMessage);\n *\n * // Multiple queues can consume the same event\n * const logsQueue1 = defineQueue('logs-queue-1', { durable: true });\n * const logsQueue2 = defineQueue('logs-queue-2', { durable: true });\n *\n * // Use in contract\n * const { consumer: consumer1, binding: binding1 } = logEvent.createConsumer(logsQueue1);\n * const { consumer: consumer2, binding: binding2 } = logEvent.createConsumer(logsQueue2);\n *\n * const contract = defineContract({\n *   exchanges: { logs: logsExchange },\n *   queues: { logsQueue1, logsQueue2 },\n *   bindings: {\n *     logBinding1: binding1,\n *     logBinding2: binding2,\n *   },\n *   publishers: { publishLog: logEvent.publisher },\n *   consumers: {\n *     consumeLog1: consumer1,\n *     consumeLog2: consumer2,\n *   },\n * });\n * ```\n */\nexport function definePublisherFirst<TMessage extends MessageDefinition>(\n  exchange: FanoutExchangeDefinition,\n  message: TMessage,\n  options?: Omit<\n    Extract<QueueBindingDefinition, { exchange: FanoutExchangeDefinition }>,\n    \"type\" | \"queue\" | \"exchange\" | \"routingKey\"\n  >,\n): PublisherFirstResult<\n  TMessage,\n  Extract<PublisherDefinition<TMessage>, { exchange: FanoutExchangeDefinition }>\n>;\n\n/**\n * Define a publisher-first relationship for event-oriented messaging.\n *\n * This builder enforces consistency by:\n * 1. Ensuring the publisher and consumer use the same message schema\n * 2. Linking the routing key from the publisher to the binding\n *\n * Use this pattern for events where publishers don't need to know about queues.\n * Multiple consumers can be created for different queues, all using the same message schema.\n *\n * @param exchange - The exchange to publish to (direct or topic type)\n * @param message - The message definition (schema and metadata)\n * @param options - Binding configuration (routingKey is required)\n * @param options.routingKey - The routing key for message routing\n * @returns A publisher-first result with publisher and consumer factory\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const ordersExchange = defineExchange('orders', 'topic', { durable: true });\n * const orderMessage = defineMessage(\n *   z.object({\n *     orderId: z.string(),\n *     amount: z.number(),\n *   })\n * );\n *\n * // Create publisher-first relationship with routing key (event pattern)\n * const orderCreatedEvent = definePublisherFirst(\n *   ordersExchange,\n *   orderMessage,\n *   { routingKey: 'order.created' }\n * );\n *\n * // Multiple queues can consume the same event\n * const orderQueue = defineQueue('order-processing', { durable: true });\n * const analyticsQueue = defineQueue('analytics', { durable: true });\n *\n * // Use in contract - routing key is consistent across publisher and bindings\n * const { consumer: processConsumer, binding: processBinding } = orderCreatedEvent.createConsumer(orderQueue);\n * const { consumer: analyticsConsumer, binding: analyticsBinding } = orderCreatedEvent.createConsumer(analyticsQueue);\n *\n * const contract = defineContract({\n *   exchanges: { orders: ordersExchange },\n *   queues: { orderQueue, analyticsQueue },\n *   bindings: {\n *     orderBinding: processBinding,\n *     analyticsBinding,\n *   },\n *   publishers: { orderCreated: orderCreatedEvent.publisher },\n *   consumers: {\n *     processOrder: processConsumer,\n *     trackOrder: analyticsConsumer,\n *   },\n * });\n * ```\n */\nexport function definePublisherFirst<TMessage extends MessageDefinition>(\n  exchange: DirectExchangeDefinition | TopicExchangeDefinition,\n  message: TMessage,\n  options: Omit<\n    Extract<\n      QueueBindingDefinition,\n      { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n    >,\n    \"type\" | \"queue\" | \"exchange\"\n  >,\n): PublisherFirstResult<\n  TMessage,\n  Extract<\n    PublisherDefinition<TMessage>,\n    { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n  >\n>;\n\n/**\n * Implementation of definePublisherFirst.\n * @internal\n */\nexport function definePublisherFirst<TMessage extends MessageDefinition>(\n  exchange: ExchangeDefinition,\n  message: TMessage,\n  options?: {\n    routingKey?: string;\n    arguments?: Record<string, unknown>;\n  },\n): PublisherFirstResult<TMessage, PublisherDefinition<TMessage>> {\n  // Create the publisher\n  const publisher = callDefinePublisher(exchange, message, options);\n\n  // Factory function to create a consumer with the same message type\n  const createConsumer = (queue: QueueDefinition) => {\n    const binding = callDefineQueueBinding(queue, exchange, options);\n    const consumer = defineConsumer(queue, message);\n    return {\n      consumer,\n      binding,\n    };\n  };\n\n  return {\n    publisher,\n    createConsumer,\n  };\n}\n\n/**\n * Consumer-first builder result.\n *\n * This type represents a consumer with its binding and provides a method to create\n * a publisher that uses the same message schema and routing key.\n *\n * @template TMessage - The message definition\n * @template TConsumer - The consumer definition\n * @template TBinding - The queue binding definition\n */\nexport type ConsumerFirstResult<\n  TMessage extends MessageDefinition,\n  TConsumer extends ConsumerDefinition<TMessage>,\n  TBinding extends QueueBindingDefinition,\n> = {\n  /** The consumer definition */\n  consumer: TConsumer;\n  /** The binding definition connecting the exchange to the queue */\n  binding: TBinding;\n  /**\n   * Create a publisher that sends messages to this consumer.\n   * The publisher will automatically use the same message schema and routing key.\n   *\n   * @returns A publisher definition with the same message type and routing key\n   */\n  createPublisher: () => PublisherDefinition<TMessage>;\n};\n\n/**\n * Define a consumer-first relationship between a consumer and publisher.\n *\n * This builder enforces consistency by:\n * 1. Ensuring the consumer and publisher use the same message schema\n * 2. Linking the routing key from the binding to the publisher\n * 3. Creating a binding that connects the exchange to the queue\n *\n * Use this when you want to start with a consumer and ensure publishers\n * send messages of the correct type.\n *\n * @param queue - The queue to consume from\n * @param exchange - The exchange that routes to the queue (fanout type)\n * @param message - The message definition (schema and metadata)\n * @param options - Optional binding configuration\n * @returns A consumer-first result with consumer, binding, and publisher factory\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const notificationsQueue = defineQueue('notifications', { durable: true });\n * const notificationsExchange = defineExchange('notifications', 'fanout', { durable: true });\n * const notificationMessage = defineMessage(\n *   z.object({\n *     userId: z.string(),\n *     message: z.string(),\n *   })\n * );\n *\n * // Create consumer-first relationship\n * const notificationConsumerFirst = defineConsumerFirst(\n *   notificationsQueue,\n *   notificationsExchange,\n *   notificationMessage\n * );\n *\n * // Use in contract\n * const contract = defineContract({\n *   exchanges: { notifications: notificationsExchange },\n *   queues: { notificationsQueue },\n *   bindings: { notificationBinding: notificationConsumerFirst.binding },\n *   publishers: { sendNotification: notificationConsumerFirst.createPublisher() },\n *   consumers: { processNotification: notificationConsumerFirst.consumer },\n * });\n * ```\n */\nexport function defineConsumerFirst<TMessage extends MessageDefinition>(\n  queue: QueueDefinition,\n  exchange: FanoutExchangeDefinition,\n  message: TMessage,\n  options?: Omit<\n    Extract<QueueBindingDefinition, { exchange: FanoutExchangeDefinition }>,\n    \"type\" | \"queue\" | \"exchange\" | \"routingKey\"\n  >,\n): ConsumerFirstResult<\n  TMessage,\n  ConsumerDefinition<TMessage>,\n  Extract<QueueBindingDefinition, { exchange: FanoutExchangeDefinition }>\n>;\n\n/**\n * Define a consumer-first relationship between a consumer and publisher.\n *\n * This builder enforces consistency by:\n * 1. Ensuring the consumer and publisher use the same message schema\n * 2. Linking the routing key from the binding to the publisher\n * 3. Creating a binding that connects the exchange to the queue\n *\n * Use this when you want to start with a consumer and ensure publishers\n * send messages with the correct type and routing key.\n *\n * @param queue - The queue to consume from\n * @param exchange - The exchange that routes to the queue (direct or topic type)\n * @param message - The message definition (schema and metadata)\n * @param options - Binding configuration (routingKey is required)\n * @param options.routingKey - The routing key for message routing\n * @returns A consumer-first result with consumer, binding, and publisher factory\n *\n * @example\n * ```typescript\n * import { z } from 'zod';\n *\n * const taskQueue = defineQueue('tasks', { durable: true });\n * const tasksExchange = defineExchange('tasks', 'direct', { durable: true });\n * const taskMessage = defineMessage(\n *   z.object({\n *     taskId: z.string(),\n *     payload: z.record(z.unknown()),\n *   })\n * );\n *\n * // Create consumer-first relationship with routing key\n * const taskConsumerFirst = defineConsumerFirst(\n *   taskQueue,\n *   tasksExchange,\n *   taskMessage,\n *   { routingKey: 'task.execute' }\n * );\n *\n * // Use in contract - routing key is consistent across consumer and publisher\n * const contract = defineContract({\n *   exchanges: { tasks: tasksExchange },\n *   queues: { taskQueue },\n *   bindings: { taskBinding: taskConsumerFirst.binding },\n *   publishers: { executeTask: taskConsumerFirst.createPublisher() },\n *   consumers: { processTask: taskConsumerFirst.consumer },\n * });\n * ```\n */\nexport function defineConsumerFirst<TMessage extends MessageDefinition>(\n  queue: QueueDefinition,\n  exchange: DirectExchangeDefinition | TopicExchangeDefinition,\n  message: TMessage,\n  options: Omit<\n    Extract<\n      QueueBindingDefinition,\n      { exchange: DirectExchangeDefinition | TopicExchangeDefinition }\n    >,\n    \"type\" | \"queue\" | \"exchange\"\n  >,\n): ConsumerFirstResult<\n  TMessage,\n  ConsumerDefinition<TMessage>,\n  Extract<QueueBindingDefinition, { exchange: DirectExchangeDefinition | TopicExchangeDefinition }>\n>;\n\n/**\n * Implementation of defineConsumerFirst.\n * @internal\n */\nexport function defineConsumerFirst<TMessage extends MessageDefinition>(\n  queue: QueueDefinition,\n  exchange: ExchangeDefinition,\n  message: TMessage,\n  options?: {\n    routingKey?: string;\n    arguments?: Record<string, unknown>;\n  },\n): ConsumerFirstResult<TMessage, ConsumerDefinition<TMessage>, QueueBindingDefinition> {\n  // Create the consumer\n  const consumer = defineConsumer(queue, message);\n\n  // Create the binding\n  const binding = callDefineQueueBinding(queue, exchange, options);\n\n  // Factory function to create a publisher with the same message type and routing key\n  const createPublisher = (): PublisherDefinition<TMessage> => {\n    return callDefinePublisher(exchange, message, options);\n  };\n\n  return {\n    consumer,\n    binding,\n    createPublisher,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AAkHA,SAAgB,eACd,MACA,MACA,SACoB;AACpB,QAAO;EACL;EACA;EACA,GAAG;EACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BH,SAAgB,YACd,MACA,SACiB;AACjB,QAAO;EACL;EACA,GAAG;EACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCH,SAAgB,cAId,SACA,SAKuC;AACvC,QAAO;EACL;EACA,GAAG;EACJ;;;;;;;;;;;;;AA4FH,SAAgB,mBACd,OACA,UACA,SAIwB;AACxB,KAAI,SAAS,SAAS,SACpB,QAAO;EACL,MAAM;EACN;EACA;EACA,GAAI,SAAS,aAAa,EAAE,WAAW,QAAQ,WAAW;EAC3D;AAGH,QAAO;EACL,MAAM;EACN;EACA;EACA,YAAY,SAAS;EACrB,GAAI,SAAS,aAAa,EAAE,WAAW,QAAQ,WAAW;EAC3D;;;;;;;;;;;;;AAmFH,SAAgB,sBACd,aACA,QACA,SAI2B;AAC3B,KAAI,OAAO,SAAS,SAClB,QAAO;EACL,MAAM;EACN;EACA;EACA,GAAI,SAAS,aAAa,EAAE,WAAW,QAAQ,WAAW;EAC3D;AAGH,QAAO;EACL,MAAM;EACN;EACA;EACA,YAAY,SAAS,cAAc;EACnC,GAAI,SAAS,aAAa,EAAE,WAAW,QAAQ,WAAW;EAC3D;;;;;;;;;;;;;AAsGH,SAAgB,gBACd,UACA,SACA,SAC+B;AAC/B,KAAI,SAAS,SAAS,SACpB,QAAO;EACL;EACA;EACD;AAGH,QAAO;EACL;EACA;EACA,YAAY,SAAS,cAAc;EACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CH,SAAgB,eACd,OACA,SACA,SAC8B;AAC9B,QAAO;EACL;EACA;EACA,GAAG;EACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEH,SAAgB,eACd,YACW;AACX,QAAO;;;;;;;AAQT,SAAS,oBACP,UACA,SACA,SAI+B;AAE/B,KAAI,SAAS,SAAS,SACpB,QAAO,gBAAgB,UAAU,SAAS,QAAQ;AAEpD,QAAO,gBAAgB,UAAU,SAAS,QAAkC;;;;;;;AAQ9E,SAAS,uBACP,OACA,UACA,SAIwB;AAExB,KAAI,SAAS,SAAS,SACpB,QAAO,mBAAmB,OAAO,UAAU,QAAQ;AAErD,QAAO,mBAAmB,OAAO,UAAU,QAAkC;;;;;;AAoL/E,SAAgB,qBACd,UACA,SACA,SAI+D;CAE/D,MAAM,YAAY,oBAAoB,UAAU,SAAS,QAAQ;CAGjE,MAAM,kBAAkB,UAA2B;EACjD,MAAM,UAAU,uBAAuB,OAAO,UAAU,QAAQ;AAEhE,SAAO;GACL,UAFe,eAAe,OAAO,QAAQ;GAG7C;GACD;;AAGH,QAAO;EACL;EACA;EACD;;;;;;AAkKH,SAAgB,oBACd,OACA,UACA,SACA,SAIqF;CAErF,MAAM,WAAW,eAAe,OAAO,QAAQ;CAG/C,MAAM,UAAU,uBAAuB,OAAO,UAAU,QAAQ;CAGhE,MAAM,wBAAuD;AAC3D,SAAO,oBAAoB,UAAU,SAAS,QAAQ;;AAGxD,QAAO;EACL;EACA;EACA;EACD"}