@amqp-contract/contract 0.1.4 → 0.2.1

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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AAA,ECH9B,yBDG8B;;;;AACE,iBCQnB,eDRmB,CAAA,uBCQoB,SDRpB,CAAA,CAAA,QAAA,EAAA,MAAA,EAAA,OAAA,ECUxB,cDVwB,EAAA,OAAA,CAAA,ECWvB,IDXuB,CCWlB,mBDXkB,CCWE,cDXF,CAAA,EAAA,UAAA,GAAA,SAAA,CAAA,CAAA,ECYhC,mBDZgC,CCYZ,cDZY,CAAA;;;;AACE,iBCsBrB,cDtBqB,CAAA,uBCuBZ,SDvBY,EAAA,6BCwBN,SDxBM,GCwBM,SDxBN,CAAA,CAAA,KAAA,EAAA,MAAA,EAAA,OAAA,EC2B1B,cD3B0B,EAAA,OAAA,CAAA,EC4BzB,ID5ByB,CC4BpB,kBD5BoB,CC4BD,cD5BC,EC4Be,oBD5Bf,CAAA,EAAA,OAAA,GAAA,SAAA,CAAA,CAAA,EC6BlC,kBD7BkC,CC6Bf,cD7Be,EC6BC,oBD7BD,CAAA;;;;AACD,iBCuCpB,cDvCoB,CAAA,kBCwChB,kBDxCgB,CCwCG,UDxCH,ECwCe,ODxCf,ECwCwB,SDxCxB,ECwCmC,WDxCnC,ECwCgD,UDxChD,CAAA,EAAA,mBCyCf,MDzCe,CAAA,MAAA,ECyCA,kBDzCA,CAAA,GCyCsB,MDzCtB,CAAA,MAAA,ECyCqC,kBDzCrC,CAAA,EAAA,gBC0ClB,MD1CkB,CAAA,MAAA,EC0CH,eD1CG,CAAA,GC0CgB,MD1ChB,CAAA,MAAA,EC0C+B,eD1C/B,CAAA,EAAA,kBC2ChB,MD3CgB,CAAA,MAAA,EC2CD,iBD3CC,CAAA,GC2CoB,MD3CpB,CAAA,MAAA,EC2CmC,iBD3CnC,CAAA,EAAA,oBC4Cd,MD5Cc,CAAA,MAAA,EC4CC,mBD5CD,CAAA,GC4CwB,MD5CxB,CAAA,MAAA,EC4CuC,mBD5CvC,CAAA,EAAA,mBC6Cf,MD7Ce,CAAA,MAAA,EC6CA,kBD7CA,CAAA,GC6CsB,MD7CtB,CAAA,MAAA,EC6CqC,kBD7CrC,CAAA,CAAA,CAAA,UAAA,EC8CtB,SD9CsB,CAAA,EC8CV,SD9CU"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/builder.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.mjs

@@ -1,67 +1,211 @@
 //#region src/builder.ts
 /**
-* Define a message schema with metadata
+* Define an AMQP exchange.
+*
+* An exchange receives messages from publishers and routes them to queues based on the exchange type
+* and routing rules. This is the implementation function - use the type-specific overloads for better
+* type safety.
+*
+* @param name - The name of the exchange
+* @param type - The type of exchange: "fanout", "direct", or "topic"
+* @param options - Optional exchange configuration
+* @returns An exchange definition
+* @internal
 */
-function defineMessage(name, schema) {
+function defineExchange(name, type, options) {
 	return {
 		name,
-		schema,
-		"~standard": schema["~standard"]
+		type,
+		...options
 	};
 }
 /**
-* Define an AMQP exchange
+* Define an AMQP queue.
+*
+* A queue stores messages until they are consumed by workers. Queues can be bound to exchanges
+* to receive messages based on routing rules.
+*
+* @param name - The name of the queue
+* @param options - Optional queue configuration
+* @param options.durable - If true, the queue survives broker restarts (default: false)
+* @param options.exclusive - If true, the queue can only be used by the declaring connection (default: false)
+* @param options.autoDelete - If true, the queue is deleted when the last consumer unsubscribes (default: false)
+* @param options.arguments - Additional AMQP arguments (e.g., x-message-ttl, x-dead-letter-exchange)
+* @returns A queue definition
+*
+* @example
+* ```typescript
+* const orderProcessingQueue = defineQueue('order-processing', {
+*   durable: true,
+*   arguments: {
+*     'x-message-ttl': 86400000, // 24 hours
+*     'x-dead-letter-exchange': 'orders-dlx'
+*   }
+* });
+* ```
 */
-function defineExchange(name, type, options) {
+function defineQueue(name, options) {
 	return {
 		name,
-		type,
 		...options
 	};
 }
 /**
-* Define an AMQP queue
+* Define a message definition with payload and optional headers/metadata.
+*
+* A message definition specifies the schema for message payloads and headers using
+* Standard Schema v1 compatible libraries (Zod, Valibot, ArkType, etc.).
+* The schemas are used for automatic validation when publishing or consuming messages.
+*
+* @param payload - The payload schema (must be Standard Schema v1 compatible)
+* @param options - Optional message metadata
+* @param options.headers - Optional header schema for message headers
+* @param options.summary - Brief description for documentation (used in AsyncAPI generation)
+* @param options.description - Detailed description for documentation (used in AsyncAPI generation)
+* @returns A message definition with inferred types
+*
+* @example
+* ```typescript
+* import { z } from 'zod';
+*
+* const orderMessage = defineMessage(
+*   z.object({
+*     orderId: z.string().uuid(),
+*     customerId: z.string().uuid(),
+*     amount: z.number().positive(),
+*     items: z.array(z.object({
+*       productId: z.string(),
+*       quantity: z.number().int().positive(),
+*     })),
+*   }),
+*   {
+*     summary: 'Order created event',
+*     description: 'Emitted when a new order is created in the system'
+*   }
+* );
+* ```
 */
-function defineQueue(name, options) {
+function defineMessage(payload, options) {
 	return {
-		name,
+		payload,
 		...options
 	};
 }
 /**
-* Define a binding between queue and exchange
+* Define a binding between a queue and an exchange.
+*
+* This is the implementation function - use the type-specific overloads for better type safety.
+*
+* @param queue - The queue definition to bind
+* @param exchange - The exchange definition
+* @param options - Optional binding configuration
+* @returns A queue binding definition
+* @internal
 */
-function defineBinding(queue, exchange, options) {
+function defineQueueBinding(queue, exchange, options) {
+	if (exchange.type === "fanout") return {
+		type: "queue",
+		queue,
+		exchange,
+		...options?.arguments && { arguments: options.arguments }
+	};
 	return {
 		type: "queue",
 		queue,
 		exchange,
-		...options
+		routingKey: options?.routingKey,
+		...options?.arguments && { arguments: options.arguments }
 	};
 }
 /**
-* Define a binding between exchange and exchange (source -> destination)
+* Define a binding between two exchanges (exchange-to-exchange routing).
+*
+* This is the implementation function - use the type-specific overloads for better type safety.
+*
+* @param destination - The destination exchange definition
+* @param source - The source exchange definition
+* @param options - Optional binding configuration
+* @returns An exchange binding definition
+* @internal
 */
 function defineExchangeBinding(destination, source, options) {
+	if (source.type === "fanout") return {
+		type: "exchange",
+		source,
+		destination,
+		...options?.arguments && { arguments: options.arguments }
+	};
 	return {
 		type: "exchange",
 		source,
 		destination,
-		...options
+		routingKey: options?.routingKey ?? "",
+		...options?.arguments && { arguments: options.arguments }
 	};
 }
 /**
-* Define a message publisher
+* Define a message publisher.
+*
+* This is the implementation function - use the type-specific overloads for better type safety.
+*
+* @param exchange - The exchange definition
+* @param message - The message definition
+* @param options - Optional publisher configuration
+* @returns A publisher definition
+* @internal
 */
 function definePublisher(exchange, message, options) {
+	if (exchange.type === "fanout") return {
+		exchange,
+		message
+	};
 	return {
 		exchange,
 		message,
-		...options
+		routingKey: options?.routingKey ?? ""
 	};
 }
 /**
-* Define a message consumer
+* Define a message consumer.
+*
+* A consumer receives and processes messages from a queue. The message schema is validated
+* automatically when messages are consumed, ensuring type safety for your handlers.
+*
+* 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.
+*
+* @param queue - The queue definition to consume from
+* @param message - The message definition with payload schema
+* @param options - Optional consumer configuration
+* @returns A consumer definition with inferred message types
+*
+* @example
+* ```typescript
+* import { z } from 'zod';
+*
+* const orderQueue = defineQueue('order-processing', { durable: true });
+* const orderMessage = defineMessage(
+*   z.object({
+*     orderId: z.string().uuid(),
+*     customerId: z.string().uuid(),
+*     amount: z.number().positive(),
+*   })
+* );
+*
+* const processOrderConsumer = defineConsumer(orderQueue, orderMessage);
+*
+* // Later, when creating a worker, you'll provide a handler for this consumer:
+* // const worker = await TypedAmqpWorker.create({
+* //   contract,
+* //   handlers: {
+* //     processOrder: async (message) => {
+* //       // message is automatically typed based on the schema
+* //       console.log(message.orderId); // string
+* //     }
+* //   },
+* //   connection
+* // });
+* ```
 */
 function defineConsumer(queue, message, options) {
 	return {
@@ -71,12 +215,78 @@ function defineConsumer(queue, message, options) {
 	};
 }
 /**
-* Define an AMQP contract
+* Define an AMQP contract.
+*
+* A contract is the central definition of your AMQP messaging topology. It brings together
+* all exchanges, queues, bindings, publishers, and consumers in a single, type-safe definition.
+*
+* The contract is used by both clients (for publishing) and workers (for consuming) to ensure
+* type safety throughout your messaging infrastructure. TypeScript will infer all message types
+* and publisher/consumer names from the contract.
+*
+* @param definition - The contract definition containing all AMQP resources
+* @param definition.exchanges - Named exchange definitions
+* @param definition.queues - Named queue definitions
+* @param definition.bindings - Named binding definitions (queue-to-exchange or exchange-to-exchange)
+* @param definition.publishers - Named publisher definitions for sending messages
+* @param definition.consumers - Named consumer definitions for receiving messages
+* @returns The same contract definition with full type inference
+*
+* @example
+* ```typescript
+* import {
+*   defineContract,
+*   defineExchange,
+*   defineQueue,
+*   defineQueueBinding,
+*   definePublisher,
+*   defineConsumer,
+*   defineMessage,
+* } from '@amqp-contract/contract';
+* import { z } from 'zod';
+*
+* // Define resources
+* const ordersExchange = defineExchange('orders', 'topic', { durable: true });
+* const orderQueue = defineQueue('order-processing', { durable: true });
+* const orderMessage = defineMessage(
+*   z.object({
+*     orderId: z.string(),
+*     amount: z.number(),
+*   })
+* );
+*
+* // Compose contract
+* export const contract = defineContract({
+*   exchanges: {
+*     orders: ordersExchange,
+*   },
+*   queues: {
+*     orderProcessing: orderQueue,
+*   },
+*   bindings: {
+*     orderBinding: defineQueueBinding(orderQueue, ordersExchange, {
+*       routingKey: 'order.created',
+*     }),
+*   },
+*   publishers: {
+*     orderCreated: definePublisher(ordersExchange, orderMessage, {
+*       routingKey: 'order.created',
+*     }),
+*   },
+*   consumers: {
+*     processOrder: defineConsumer(orderQueue, orderMessage),
+*   },
+* });
+*
+* // TypeScript now knows:
+* // - client.publish('orderCreated', { orderId: string, amount: number })
+* // - handler: async (message: { orderId: string, amount: number }) => void
+* ```
 */
 function defineContract(definition) {
 	return definition;
 }
 
 //#endregion
-export { defineBinding, defineConsumer, defineContract, defineExchange, defineExchangeBinding, defineMessage, definePublisher, defineQueue };
+export { defineConsumer, defineContract, defineExchange, defineExchangeBinding, defineMessage, definePublisher, 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 {\n  AnySchema,\n  BindingDefinition,\n  QueueBindingDefinition,\n  ExchangeBindingDefinition,\n  ConsumerDefinition,\n  ContractDefinition,\n  ExchangeDefinition,\n  ExchangeType,\n  PublisherDefinition,\n  QueueDefinition,\n} from \"./types.js\";\n\n/**\n * Message schema with metadata\n */\nexport interface MessageSchema<TSchema extends AnySchema = AnySchema> extends AnySchema {\n  readonly name: string;\n  readonly schema: TSchema;\n  readonly \"~standard\": TSchema[\"~standard\"];\n}\n\n/**\n * Define a message schema with metadata\n */\nexport function defineMessage<TSchema extends AnySchema>(\n  name: string,\n  schema: TSchema,\n): MessageSchema<TSchema> {\n  return {\n    name,\n    schema,\n    \"~standard\": schema[\"~standard\"],\n  };\n}\n\n/**\n * Define an AMQP exchange\n */\nexport function defineExchange(\n  name: string,\n  type: ExchangeType,\n  options?: Omit<ExchangeDefinition, \"name\" | \"type\">,\n): ExchangeDefinition {\n  return {\n    name,\n    type,\n    ...options,\n  };\n}\n\n/**\n * Define an AMQP queue\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 binding between queue and exchange\n */\nexport function defineBinding(\n  queue: string,\n  exchange: string,\n  options?: Omit<QueueBindingDefinition, \"type\" | \"queue\" | \"exchange\">,\n): QueueBindingDefinition {\n  return {\n    type: \"queue\",\n    queue,\n    exchange,\n    ...options,\n  };\n}\n\n/**\n * Define a binding between exchange and exchange (source -> destination)\n */\nexport function defineExchangeBinding(\n  destination: string,\n  source: string,\n  options?: Omit<ExchangeBindingDefinition, \"type\" | \"source\" | \"destination\">,\n): ExchangeBindingDefinition {\n  return {\n    type: \"exchange\",\n    source,\n    destination,\n    ...options,\n  };\n}\n\n/**\n * Define a message publisher\n */\nexport function definePublisher<TMessageSchema extends AnySchema>(\n  exchange: string,\n  message: TMessageSchema,\n  options?: Omit<PublisherDefinition<TMessageSchema>, \"exchange\" | \"message\">,\n): PublisherDefinition<TMessageSchema> {\n  return {\n    exchange,\n    message,\n    ...options,\n  };\n}\n\n/**\n * Define a message consumer\n */\nexport function defineConsumer<\n  TMessageSchema extends AnySchema,\n  THandlerResultSchema extends AnySchema = AnySchema,\n>(\n  queue: string,\n  message: TMessageSchema,\n  options?: Omit<ConsumerDefinition<TMessageSchema, THandlerResultSchema>, \"queue\" | \"message\">,\n): ConsumerDefinition<TMessageSchema, THandlerResultSchema> {\n  return {\n    queue,\n    message,\n    ...options,\n  };\n}\n\n/**\n * Define an AMQP contract\n */\nexport function defineContract<\n  TContract extends ContractDefinition<TExchanges, TQueues, TBindings, TPublishers, TConsumers>,\n  TExchanges extends Record<string, ExchangeDefinition> = Record<string, ExchangeDefinition>,\n  TQueues extends Record<string, QueueDefinition> = Record<string, QueueDefinition>,\n  TBindings extends Record<string, BindingDefinition> = Record<string, BindingDefinition>,\n  TPublishers extends Record<string, PublisherDefinition> = Record<string, PublisherDefinition>,\n  TConsumers extends Record<string, ConsumerDefinition> = Record<string, ConsumerDefinition>,\n>(definition: TContract): TContract {\n  return definition;\n}\n"],"mappings":";;;;AAyBA,SAAgB,cACd,MACA,QACwB;AACxB,QAAO;EACL;EACA;EACA,aAAa,OAAO;EACrB;;;;;AAMH,SAAgB,eACd,MACA,MACA,SACoB;AACpB,QAAO;EACL;EACA;EACA,GAAG;EACJ;;;;;AAMH,SAAgB,YACd,MACA,SACiB;AACjB,QAAO;EACL;EACA,GAAG;EACJ;;;;;AAMH,SAAgB,cACd,OACA,UACA,SACwB;AACxB,QAAO;EACL,MAAM;EACN;EACA;EACA,GAAG;EACJ;;;;;AAMH,SAAgB,sBACd,aACA,QACA,SAC2B;AAC3B,QAAO;EACL,MAAM;EACN;EACA;EACA,GAAG;EACJ;;;;;AAMH,SAAgB,gBACd,UACA,SACA,SACqC;AACrC,QAAO;EACL;EACA;EACA,GAAG;EACJ;;;;;AAMH,SAAgB,eAId,OACA,SACA,SAC0D;AAC1D,QAAO;EACL;EACA;EACA,GAAG;EACJ;;;;;AAMH,SAAgB,eAOd,YAAkC;AAClC,QAAO"}
+{"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"}