@amqp-contract/contract 0.3.5 → 0.5.0

package/dist/index.d.cts

@@ -855,6 +855,533 @@ declare function defineConsumer<TMessage extends MessageDefinition>(queue: Queue
  * ```
  */
 declare function defineContract<TContract extends ContractDefinition>(definition: TContract): TContract;
+/**
+ * Publisher-first builder result for fanout and direct exchanges.
+ *
+ * This type represents a publisher and provides a method to create
+ * a consumer that uses the same message schema with a binding to the exchange.
+ *
+ * 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;
+  };
+};
+/**
+ * Type-safe routing key that validates basic format.
+ *
+ * Validates that a routing key follows basic AMQP routing key rules:
+ * - Must not contain wildcards (* or #)
+ * - Must not be empty
+ * - Should contain alphanumeric characters, dots, hyphens, and underscores
+ *
+ * Note: Full character-by-character validation is not performed to avoid TypeScript
+ * recursion depth limits. Runtime validation is still recommended.
+ *
+ * @public
+ * @template S - The routing key string to validate
+ * @example
+ * ```typescript
+ * type Valid = RoutingKey<"order.created">; // "order.created"
+ * type Invalid = RoutingKey<"order.*">; // never (contains wildcard)
+ * type Invalid2 = RoutingKey<"">; // never (empty string)
+ * ```
+ */
+type RoutingKey<S extends string> = S extends "" ? never : S extends `${string}*${string}` | `${string}#${string}` ? never : S;
+/**
+ * Type-safe binding pattern that validates basic format and wildcards.
+ *
+ * Validates that a binding pattern follows basic AMQP binding pattern rules:
+ * - Can contain wildcards (* for one word, # for zero or more words)
+ * - Must not be empty
+ * - Should contain alphanumeric characters, dots, hyphens, underscores, and wildcards
+ *
+ * Note: Full character-by-character validation is not performed to avoid TypeScript
+ * recursion depth limits. Runtime validation is still recommended.
+ *
+ * @public
+ * @template S - The binding pattern string to validate
+ * @example
+ * ```typescript
+ * type ValidPattern = BindingPattern<"order.*">; // "order.*"
+ * type ValidHash = BindingPattern<"order.#">; // "order.#"
+ * type ValidConcrete = BindingPattern<"order.created">; // "order.created"
+ * type Invalid = BindingPattern<"">; // never (empty string)
+ * ```
+ */
+type BindingPattern<S extends string> = S extends "" ? never : S;
+/**
+ * Helper type for pattern matching with # in the middle
+ * Handles backtracking to match # with zero or more segments
+ * @internal
+ */
+type MatchesAfterHash<Key extends string, PatternRest$1 extends string> = MatchesPattern<Key, PatternRest$1> extends true ? true : Key extends `${string}.${infer KeyRest}` ? MatchesAfterHash<KeyRest, PatternRest$1> : false;
+/**
+ * Check if a routing key matches a binding pattern
+ * Implements AMQP topic exchange pattern matching:
+ * - * matches exactly one word
+ * - # matches zero or more words
+ * @internal
+ */
+type MatchesPattern<Key extends string, Pattern extends string> = Pattern extends `${infer PatternPart}.${infer PatternRest}` ? PatternPart extends "#" ? MatchesAfterHash<Key, PatternRest> : Key extends `${infer KeyPart}.${infer KeyRest}` ? PatternPart extends "*" ? MatchesPattern<KeyRest, PatternRest> : PatternPart extends KeyPart ? MatchesPattern<KeyRest, PatternRest> : false : false : Pattern extends "#" ? true : Pattern extends "*" ? Key extends `${string}.${string}` ? false : true : Pattern extends Key ? true : false;
+/**
+ * Validate that a routing key matches a binding pattern.
+ *
+ * This is a utility type provided for users who want compile-time validation
+ * that a routing key matches a specific pattern. It's not enforced internally
+ * in the API to avoid TypeScript recursion depth issues with complex routing keys.
+ *
+ * Returns the routing key if it's valid and matches the pattern, `never` otherwise.
+ *
+ * @example
+ * ```typescript
+ * type ValidKey = MatchingRoutingKey<"order.*", "order.created">; // "order.created"
+ * type InvalidKey = MatchingRoutingKey<"order.*", "user.created">; // never
+ * ```
+ *
+ * @template Pattern - The binding pattern (can contain * and # wildcards)
+ * @template Key - The routing key to validate
+ */
+type MatchingRoutingKey<Pattern extends string, Key extends string> = RoutingKey<Key> extends never ? never : BindingPattern<Pattern> extends never ? never : MatchesPattern<Key, Pattern> extends true ? Key : never;
+/**
+ * Publisher-first builder result for topic exchanges.
+ *
+ * This type represents a publisher with a concrete routing key and provides a method
+ * to create consumers that can use routing key patterns matching the publisher's key.
+ *
+ * @template TMessage - The message definition
+ * @template TPublisher - The publisher definition
+ * @template TRoutingKey - The literal routing key type from the publisher (for documentation purposes)
+ */
+type PublisherFirstResultWithRoutingKey<TMessage extends MessageDefinition, TPublisher extends PublisherDefinition<TMessage>, TRoutingKey extends string> = {
+  /** The publisher definition */
+  publisher: TPublisher;
+  /**
+   * Create a consumer that receives messages from this publisher.
+   * For topic exchanges, the routing key pattern can be specified for the binding.
+   *
+   * @param queue - The queue that will consume the messages
+   * @param routingKey - Optional routing key pattern for the binding (defaults to publisher's routing key)
+   * @returns An object with the consumer definition and binding
+   */
+  createConsumer: <TConsumerRoutingKey extends string = TRoutingKey>(queue: QueueDefinition, routingKey?: BindingPattern<TConsumerRoutingKey>) => {
+    consumer: ConsumerDefinition<TMessage>;
+    binding: QueueBindingDefinition;
+  };
+};
+/**
+ * Define a publisher-first relationship for event-oriented messaging.
+ *
+ * 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 with direct exchange.
+ *
+ * This builder enforces consistency by:
+ * 1. Ensuring the publisher and consumer use the same message schema
+ * 2. Linking the routing key from the publisher to the binding
+ *
+ * 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 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 tasksExchange = defineExchange('tasks', 'direct', { durable: true });
+ * const taskMessage = defineMessage(
+ *   z.object({
+ *     taskId: z.string(),
+ *     payload: z.record(z.unknown()),
+ *   })
+ * );
+ *
+ * // Create publisher-first relationship with routing key
+ * const taskEvent = definePublisherFirst(
+ *   tasksExchange,
+ *   taskMessage,
+ *   { routingKey: 'task.execute' }
+ * );
+ *
+ * // Use in contract - routing key is consistent across publisher and bindings
+ * const taskQueue = defineQueue('task-queue', { durable: true });
+ * const { consumer, binding } = taskEvent.createConsumer(taskQueue);
+ *
+ * const contract = defineContract({
+ *   exchanges: { tasks: tasksExchange },
+ *   queues: { taskQueue },
+ *   bindings: { taskBinding: binding },
+ *   publishers: { executeTask: taskEvent.publisher },
+ *   consumers: { processTask: consumer },
+ * });
+ * ```
+ */
+declare function definePublisherFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(exchange: DirectExchangeDefinition, message: TMessage, options: {
+  routingKey: RoutingKey<TRoutingKey>;
+  arguments?: Record<string, unknown>;
+}): PublisherFirstResult<TMessage, Extract<PublisherDefinition<TMessage>, {
+  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+}>>;
+/**
+ * Define a publisher-first relationship for event-oriented messaging with topic exchange.
+ *
+ * This builder enforces consistency by:
+ * 1. Ensuring the publisher and consumer use the same message schema
+ * 2. The publisher uses a concrete routing key (e.g., 'order.created')
+ * 3. Consumers can optionally specify routing key patterns (e.g., 'order.*') or use the default
+ *
+ * Use this pattern for events where publishers emit with specific routing keys,
+ * and consumers can subscribe with patterns. This is less common than the consumer-first pattern.
+ *
+ * @param exchange - The exchange to publish to (topic type)
+ * @param message - The message definition (schema and metadata)
+ * @param options - Binding configuration (routingKey is required)
+ * @param options.routingKey - The concrete routing key for the publisher
+ * @returns A publisher-first result with publisher and consumer factory that accepts optional routing key patterns
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
+ * const orderMessage = defineMessage(
+ *   z.object({
+ *     orderId: z.string(),
+ *     amount: z.number(),
+ *   })
+ * );
+ *
+ * // Create publisher-first relationship with concrete routing key
+ * const orderCreatedEvent = definePublisherFirst(
+ *   ordersExchange,
+ *   orderMessage,
+ *   { routingKey: 'order.created' }  // Concrete key
+ * );
+ *
+ * // Consumers can use patterns or specific keys
+ * const orderQueue = defineQueue('order-processing', { durable: true });
+ * const allOrdersQueue = defineQueue('all-orders', { durable: true });
+ *
+ * // Use in contract
+ * const { consumer: processConsumer, binding: processBinding } =
+ *   orderCreatedEvent.createConsumer(orderQueue);  // Uses 'order.created'
+ * const { consumer: allOrdersConsumer, binding: allOrdersBinding } =
+ *   orderCreatedEvent.createConsumer(allOrdersQueue, 'order.*');  // Uses pattern
+ *
+ * const contract = defineContract({
+ *   exchanges: { orders: ordersExchange },
+ *   queues: { orderQueue, allOrdersQueue },
+ *   bindings: {
+ *     orderBinding: processBinding,
+ *     allOrdersBinding,
+ *   },
+ *   publishers: { orderCreated: orderCreatedEvent.publisher },
+ *   consumers: {
+ *     processOrder: processConsumer,
+ *     trackAllOrders: allOrdersConsumer,
+ *   },
+ * });
+ * ```
+ */
+declare function definePublisherFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(exchange: TopicExchangeDefinition, message: TMessage, options: {
+  routingKey: RoutingKey<TRoutingKey>;
+  arguments?: Record<string, unknown>;
+}): PublisherFirstResultWithRoutingKey<TMessage, Extract<PublisherDefinition<TMessage>, {
+  exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+}>, TRoutingKey>;
+/**
+ * Consumer-first builder result for fanout and direct exchanges.
+ *
+ * This type represents a consumer with its binding and provides a method to create
+ * a publisher that uses the same message schema and routing key.
+ *
+ * @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: () => TBinding["exchange"] extends FanoutExchangeDefinition ? Extract<PublisherDefinition<TMessage>, {
+    exchange: FanoutExchangeDefinition;
+  }> : Extract<PublisherDefinition<TMessage>, {
+    exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+  }>;
+};
+/**
+ * Consumer-first builder result for topic exchanges.
+ *
+ * This type represents a consumer with its binding (which may use a pattern) and provides
+ * a method to create a publisher with a concrete routing key that matches the pattern.
+ *
+ * @template TMessage - The message definition
+ * @template TConsumer - The consumer definition
+ * @template TBinding - The queue binding definition
+ */
+type ConsumerFirstResultWithRoutingKey<TMessage extends MessageDefinition, TConsumer extends ConsumerDefinition<TMessage>, TBinding extends QueueBindingDefinition> = {
+  /** The consumer definition */
+  consumer: TConsumer;
+  /** The binding definition connecting the exchange to the queue */
+  binding: TBinding;
+  /**
+   * Create a publisher that sends messages to this consumer.
+   * For topic exchanges, the routing key can be specified to match the binding pattern.
+   *
+   * @param routingKey - The concrete routing key that matches the binding pattern
+   * @returns A publisher definition with the specified routing key
+   */
+  createPublisher: <TPublisherRoutingKey extends string>(routingKey: RoutingKey<TPublisherRoutingKey>) => Extract<PublisherDefinition<TMessage>, {
+    exchange: DirectExchangeDefinition | TopicExchangeDefinition;
+  }>;
+};
+/**
+ * Define a consumer-first relationship between a consumer and publisher.
+ *
+ * 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 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, TRoutingKey extends string>(queue: QueueDefinition, exchange: DirectExchangeDefinition, message: TMessage, options: {
+  routingKey: RoutingKey<TRoutingKey>;
+  arguments?: Record<string, unknown>;
+}): ConsumerFirstResult<TMessage, ConsumerDefinition<TMessage>, Extract<QueueBindingDefinition, {
+  exchange: DirectExchangeDefinition;
+}>>;
+/**
+ * Define a consumer-first relationship between a consumer and publisher with topic exchange.
+ *
+ * This builder enforces consistency by:
+ * 1. Ensuring the consumer and publisher use the same message schema
+ * 2. The binding uses a routing key pattern (e.g., 'order.*')
+ * 3. The publisher factory accepts a concrete routing key that matches the pattern (e.g., 'order.created')
+ *
+ * Use this when you want to start with a consumer that uses a routing key pattern,
+ * and allow publishers to specify concrete routing keys that match that pattern.
+ *
+ * @param queue - The queue to consume from
+ * @param exchange - The exchange that routes to the queue (topic type)
+ * @param message - The message definition (schema and metadata)
+ * @param options - Binding configuration (routingKey is required)
+ * @param options.routingKey - The routing key pattern for the binding (can use wildcards)
+ * @returns A consumer-first result with consumer, binding, and publisher factory that accepts a routing key
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const orderQueue = defineQueue('order-processing', { durable: true });
+ * const ordersExchange = defineExchange('orders', 'topic', { durable: true });
+ * const orderMessage = defineMessage(
+ *   z.object({
+ *     orderId: z.string(),
+ *     amount: z.number(),
+ *   })
+ * );
+ *
+ * // Create consumer-first relationship with pattern
+ * const orderConsumerFirst = defineConsumerFirst(
+ *   orderQueue,
+ *   ordersExchange,
+ *   orderMessage,
+ *   { routingKey: 'order.*' }  // Pattern in binding
+ * );
+ *
+ * // Use in contract - publisher can specify concrete routing key
+ * const contract = defineContract({
+ *   exchanges: { orders: ordersExchange },
+ *   queues: { orderQueue },
+ *   bindings: { orderBinding: orderConsumerFirst.binding },
+ *   publishers: {
+ *     orderCreated: orderConsumerFirst.createPublisher('order.created'),  // Concrete key
+ *     orderUpdated: orderConsumerFirst.createPublisher('order.updated'),  // Concrete key
+ *   },
+ *   consumers: { processOrder: orderConsumerFirst.consumer },
+ * });
+ * ```
+ */
+declare function defineConsumerFirst<TMessage extends MessageDefinition, TRoutingKey extends string>(queue: QueueDefinition, exchange: TopicExchangeDefinition, message: TMessage, options: {
+  routingKey: BindingPattern<TRoutingKey>;
+  arguments?: Record<string, unknown>;
+}): ConsumerFirstResultWithRoutingKey<TMessage, ConsumerDefinition<TMessage>, Extract<QueueBindingDefinition, {
+  exchange: TopicExchangeDefinition;
+}>>;
 //#endregion
-export { type AnySchema, type BaseExchangeDefinition, type BindingDefinition, type ConsumerDefinition, type 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 BindingPattern, type ConsumerDefinition, type ConsumerFirstResult, type ConsumerFirstResultWithRoutingKey, type ContractDefinition, type DirectExchangeDefinition, type ExchangeBindingDefinition, type ExchangeDefinition, type FanoutExchangeDefinition, type InferConsumerNames, type InferPublisherNames, type MatchingRoutingKey, type MessageDefinition, type PublisherDefinition, type PublisherFirstResult, type PublisherFirstResultWithRoutingKey, type QueueBindingDefinition, type QueueDefinition, type RoutingKey, type TopicExchangeDefinition, defineConsumer, defineConsumerFirst, defineContract, defineExchange, defineExchangeBinding, defineMessage, definePublisher, definePublisherFirst, defineQueue, defineQueueBinding };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/builder.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/builder.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;AAQA;AA6CA;AAiBA;AAqBA;AASA;;AAEI,KAtGQ,SAAA,GAAY,gBAsGpB;;;AASJ;AAuDA;;;AAEoC,KAhKxB,sBAAA,GAgKwB;EAAjB;;;EAYC,IAAA,EAAA,MAAA;EAsBR;;;;EAe+B,OAAA,CAAA,EAAA,OAAA;EAU3B;;AAuBhB;;EAUc,UAAA,CAAA,EAAA,OAAA;EAIA;;;;AAsBd;EAmBY,QAAA,CAAA,EAAA,OAAA;EAAqC;;;;EAMN,SAAA,CAAA,EAlR7B,MAkR6B,CAAA,MAAA,EAAA,OAAA,CAAA;CAS3B;;AAsBhB;;;;;;AAyCA;;;;;;AAiBa,KA3VD,wBAAA,GAA2B,sBA2V1B,GAAA;EAOiB,IAAA,EAAA,QAAA;CAAf;;;;AAyBf;;;;;;AAkBA;;;;AACiE,KA7XrD,wBAAA,GAA2B,sBA6X0B,GAAA;EAAS,IAAA,EAAA,QAAA;;;;ACxa1E;;;;;AA4BA;;;;;AA6BA;;;;;AAwDgB,KDjDJ,uBAAA,GAA0B,sBCiDX,GAAA;EAEV,IAAA,EAAA,OAAA;CAAL;;;AA2CZ;;;AAEmB,KDvFP,kBAAA,GACR,wBCsFe,GDrFf,wBCqFe,GDpFf,uBCoFe;;;;;;;AAmCH,KD/GJ,eAAA,GC+GsB;EACzB;;;EAGuC,IAAA,EAAA,MAAA;EAA5C;;;;EAGD,OAAA,CAAA,EAAA,OAAA;EAAO;AAoCV;;;;EAKM,SAAA,CAAA,EAAA,OAAA;EACY;;;;EAKhB,UAAA,CAAA,EAAA,OAAA;EACY;;;;AA6Dd;;;;;;;;;;;AAiCA;;;;;;EAM2C,SAAA,CAAA,ED5N7B,MC4N6B,CAAA,MAAA,EAAA,OAAA,CAAA;CAFvC;;;;;;;AA6EY,KD9RJ,iBC8RmB,CAAA,iBD7RZ,SC6RY,GD7RA,SC6RA,EAAA,iBD5RZ,gBC4RY,CD5RK,MC4RL,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,GAAA,SAAA,GAAA,SAAA,CAAA,GAAA;EAAkB;;;;EAIrC,OAAA,ED1RD,QC0RC;EAA2C;;;;EAG5C,OAAA,CAAA,EDvRC,QCuRD;EAA2C;;;AAqCtD;EAAiD,OAAA,CAAA,EAAA,MAAA;EACrC;;;;EAIN,WAAA,CAAA,EAAA,MAAA;CACY;;;;;;;;AAIf,KDhTS,sBAAA,GCgTT;EAAO;EA6EM,IAAA,EAAA,OAAA;EAAgC;EACvC,KAAA,EDzXA,eCyXA;EACE;;;;EAEW,SAAA,CAAA,EDtXR,MCsXQ,CAAA,MAAA,EAAA,OAAA,CAAA;CAAnB,GAAA,CAAA;EAAkB;EA6EL,QAAA,ED/bA,wBC+bc,GD/ba,uBC+bb;EAAmB;;;;AA0DjD;EACmB,UAAA,EAAA,MAAA;CACsB,GAAA;EAApB;EAGR,QAAA,EDpfG,wBCofH;EASa;EACO,UAAA,CAAA,EAAA,KAAA;CAAnB,CAAA;;;AA6Bd;;;;;AA2BA;AAAwE;;;;;;;;;AAqBnE,KDpjBO,yBAAA,GCojBO;EAGf;EAEmB,IAAA,EAAA,UAAA;EAAK;EAAtB,WAAA,EDpjBS,kBCojBT;EACA;;;EAEI,SAAA,CAAA,EDljBI,MCkjBJ,CAAA,MAAA,EAAA,OAAA,CAAA;CAEiB,GAAA,CAAA;EAAS;EAAxB,MAAA,EDhjBE,wBCgjBF,GDhjB6B,uBCgjB7B;EAGR;;;;EAMoB,UAAA,EAAA,MAAA;CAAG,GAAA;EAsBf;EACC,MAAA,EDvkBC,wBCukBD;EAAX;EAEmB,UAAA,CAAA,EAAA,KAAA;CAAf,CAAA;;;;;;AAgBN;;AAEyC,KD9kB7B,iBAAA,GAAoB,sBC8kBS,GD9kBgB,yBC8kBhB;;;;;;;;;;;AA2EzC;;;;;;;AAGY,KDzoBA,mBCyoBA,CAAA,iBDzoBqC,iBCyoBrC,GDzoByD,iBCyoBzD,CAAA,GAAA;EAKV;EAC4B,OAAA,ED7oBnB,QC6oBmB;CAApB,GAAA,CAAA;EAA2C;EAAnD,QAAA,EDzoBc,wBCyoBd,GDzoByC,uBCyoBzC;EAFC;;AAqDH;;EAIY,UAAA,EAAA,MAAA;CACD,GAAA;EAEgB;EAAX,QAAA,ED1rBA,wBC0rBA;EACA;EAGd,UAAA,CAAA,EAAA,KAAA;CAEsB,CAAA;;;;;;;AAkExB;;;;;;;;;;AAcgB,KD1vBJ,kBC0vBI,CAAA,iBD1vBgC,iBC0vBhC,GD1vBoD,iBC0vBpD,CAAA,GAAA;EAA2B;EAFzC,KAAA,EDtvBO,eCsvBP;EAIA;EANC,OAAA,EDjvBQ,QCivBR;CAAkC;AAsErC;;;;;;;;;;;;;;;;;;;AAiCA;;;;;;;;;;;;;;AAkBc,KDt0BF,kBAAA,GCs0BE;EAqDE;;;;EAGL,SAAA,CAAA,EDz3BG,MCy3BH,CAAA,MAAA,EDz3BkB,kBCy3BlB,CAAA;EAEC;;;;EAIV,MAAA,CAAA,EDz3BS,MCy3BT,CAAA,MAAA,EDz3BwB,eCy3BxB,CAAA;EACmB;;;;EACnB,QAAA,CAAA,EDr3BW,MCq3BX,CAAA,MAAA,EDr3B0B,iBCq3B1B,CAAA;EAHC;;AAuDH;;;EAEY,UAAA,CAAA,EDp6BG,MCo6BH,CAAA,MAAA,EDp6BkB,mBCo6BlB,CAAA;EACD;;;;;EAOU,SAAA,CAAA,EDr6BP,MCq6BO,CAAA,MAAA,EDr6BQ,kBCq6BR,CAAA;CAAnB;;;;;;AAwDF;;;;;;;;;;AAUE,KDr9BU,mBCq9BV,CAAA,kBDr9BgD,kBCq9BhD,CAAA,GDp9BA,SCo9BA,CAAA,YAAA,CAAA,SDp9BgC,MCo9BhC,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,MDp9BgE,SCo9BhE,CAAA,YAAA,CAAA,GAAA,KAAA;;;;;;;;;;;;;;;;KDn8BU,qCAAqC,sBAC/C,+BAA+B,gCAAgC;;;;AAncjE;AAQA;AA6CA;AAiBA;AAqBA;AASA;;;;;AAWA;AAuDA;;;;;;;;AAoCA;;AAWc,iBC1LE,cAAA,CD0LF,IAAA,EAAA,MAAA,EAAA,IAAA,EAAA,QAAA,EAAA,OAAA,CAAA,ECvLF,IDuLE,CCvLG,sBDuLH,EAAA,MAAA,GAAA,MAAA,CAAA,CAAA,ECtLX,wBDsLW;;;;;AAqCd;;;;;;;AAoCA;AAmBA;;;;;;;;AAqCA;;AAAoE,iBC/RpD,cAAA,CD+RoD,IAAA,EAAA,MAAA,EAAA,IAAA,EAAA,QAAA,EAAA,OAAA,CAAA,EC5RxD,ID4RwD,CC5RnD,sBD4RmD,EAAA,MAAA,GAAA,MAAA,CAAA,CAAA,EC3RjE,wBD2RiE;;;;AAyCpE;;;;;;;;;;;;AAiDA;;;;;;AAkBA;;AACE,iBC/Wc,cAAA,CD+Wd,IAAA,EAAA,MAAA,EAAA,IAAA,EAAA,OAAA,EAAA,OAAA,CAAA,EC5WU,ID4WV,CC5We,sBD4Wf,EAAA,MAAA,GAAA,MAAA,CAAA,CAAA,EC3WC,uBD2WD;;;;;;;ACxaF;;;;;AA4BA;;;;;AA6BA;;;;;AAwDA;;;;AAGkB,iBAHF,WAAA,CAGE,IAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EADN,IACM,CADD,eACC,EAAA,MAAA,CAAA,CAAA,EAAf,eAAe;AA0ClB;;;;;;;;;;AAqCA;;;;;;;;;;;AA2CA;;;;;;;;;;;;;;AAyEgB,iBAzJA,aAyJqB,CAAA,iBAxJlB,iBAwJkB,CAAA,SAAA,CAAA,EAAA,iBAvJlB,gBAuJkB,CAvJD,MAuJC,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,GAAA,SAAA,GAAA,SAAA,CAAA,CAAA,OAAA,EArJ1B,QAqJ0B,EAAA,OAIY,CAJZ,EAAA;EACtB,OAAA,CAAA,EApJD,QAoJC;EACL,OAAA,CAAA,EAAA,MAAA;EAEE,WAAA,CAAA,EAAA,MAAA;CAAqC,CAAA,EAnJ9C,iBAmJ8C,CAnJ5B,QAmJ4B,EAnJlB,QAmJkB,CAAA;;;;;;;AA6BjD;;;;;;;;;;;;;;AAiFgB,iBAtOA,kBAAA,CAsOe,KAAA,EArOtB,eAqOsB,EAAA,QAAA,EApOnB,wBAoOmB,EAAA,OACnB,CADmB,EAnOnB,IAmOmB,CAlO3B,OAkO2B,CAlOnB,sBAkOmB,EAAA;EAAkB,QAAA,EAlOD,wBAkOC;CACrC,CAAA,EAAA,MAAA,GAAA,OAAA,GAAA,UAAA,GAAA,YAAA,CAAA,CAAA,EAhOT,OAgOS,CAhOD,sBAgOC,EAAA;EACD,QAAA,EAjOoC,wBAiOpC;CAEqB,CAAA;;;;;;;;;;AAwChC;;;;;;;;;;;;;;;;;AAuFA;;;;;;;;AAIG,iBAlUa,kBAAA,CAkUb,KAAA,EAjUM,eAiUN,EAAA,QAAA,EAhUS,wBAgUT,GAhUoC,uBAgUpC,EAAA,OAAA,EA/TQ,IA+TR,CA9TC,OA8TD,CA7TG,sBA6TH,EAAA;EAAkB,QAAA,EA5TH,wBA4TG,GA5TwB,uBA4TxB;AA6ErB,CAAA,CAAA,EAAgB,MAAA,GAAA,OAAA,GAAc,UAAA,CAAA,CAAA,EArY3B,OAqY2B,CApY5B,sBAoY4B,EAAA;EAAmB,QAAA,EAnYnC,wBAmYmC,GAnYR,uBAmYQ;CACnC,CAAA;;;AAyDd;;;;;;;;;;AA4CA;;;;;AA2BA;AAAwE;;;AAQtE,iBA/cc,qBAAA,CA+cd,WAAA,EA9ca,kBA8cb,EAAA,MAAA,EA7cQ,wBA6cR,EAAA,OAGuB,CAHvB,EA5cU,IA4cV,CA3cE,OA2cF,CA3cU,yBA2cV,EAAA;EAEI,MAAA,EA7c2C,wBA6c3C;CACmB,CAAA,EAAA,MAAA,GAAA,QAAA,GAAA,aAAA,GAAA,YAAA,CAAA,CAAA,EA3ctB,OA2csB,CA3cd,yBA2cc,EAAA;EAAS,MAAA,EA3cc,wBA2cd;CAA1B,CAAA;;AAAgB;;;;;;;;;;;;;;;;;;AAmDxB;;;;;AAKuB,iBAzeP,qBAAA,CAyeO,WAAA,EAxeR,kBAweQ,EAAA,MAAA,EAveb,wBAuea,GAvec,uBAued,EAAA,OAAA,EAteZ,IAseY,CArenB,OAqemB,CApejB,yBAoeiB,EAAA;EAAK,MAAA,EAneZ,wBAmeY,GAnee,uBAmef;CAApB,CAAA,EAAA,MAAA,GAAA,QAAA,GAAA,aAAA,CAAA,CAAA,EA/dL,OA+dK,CA9dN,yBA8dM,EAAA;EACE,MAAA,EA9dE,wBA8dF,GA9d6B,uBA8d7B;CAAG,CAAA;AAab;;;;;;;;;;;;;AA6EA;;;;;;;;;;;;;;;AA4DA;AACmB,iBAhjBH,eAgjBG,CAAA,iBAhjB8B,iBAgjB9B,CAAA,CAAA,QAAA,EA/iBP,wBA+iBO,EAAA,OAAA,EA9iBR,QA8iBQ,EAAA,OAIR,CAJQ,EA7iBP,IA6iBO,CA5iBf,OA4iBe,CA5iBP,mBA4iBO,CA5iBa,QA4iBb,CAAA,EAAA;EAGP,QAAA,EA/iB2C,wBA+iB3C;CACD,CAAA,EAAA,UAAA,GAAA,SAAA,GAAA,YAAA,CAAA,CAAA,EA7iBR,OA6iBQ,CA7iBA,mBA6iBA,CA7iBoB,QA6iBpB,CAAA,EAAA;EAEgB,QAAA,EA/iB2B,wBA+iB3B;CAAX,CAAA;;;;;;;;;;AAwEhB;;;;;;;;;;;;;;;;AAgFA;;;;;;;;;;AAgBc,iBAlrBE,eAkrBF,CAAA,iBAlrBmC,iBAkrBnC,CAAA,CAAA,QAAA,EAjrBF,wBAirBE,GAjrByB,uBAirBzB,EAAA,OAAA,EAhrBH,QAgrBG,EAAA,OAAA,EA/qBH,IA+qBG,CA9qBV,OA8qBU,CA7qBR,mBA6qBQ,CA7qBY,QA6qBZ,CAAA,EAAA;EAA2C,QAAA,EA5qBvC,wBA4qBuC,GA5qBZ,uBA4qBY;CAAnD,CAAA,EAAA,UAAA,GAAA,SAAA,CAAA,CAAA,EAxqBH,OAwqBG,CAvqBJ,mBAuqBI,CAvqBgB,QAuqBhB,CAAA,EAAA;EAEsB,QAAA,EAxqBd,wBAwqBc,GAxqBa,uBAwqBb;CAApB,CAAA;;;;;AAeR;;;;;;;;;;;;;;;AAuEA;;;;;;;;;;;;;;;;;AA+DA;;;;;;AAKgB,iBAvvBA,cAuvBA,CAAA,iBAvvBgC,iBAuvBhC,CAAA,CAAA,KAAA,EAtvBP,eAsvBO,EAAA,OAAA,EArvBL,QAqvBK,EAAA,OAAA,CAAA,EApvBJ,IAovBI,CApvBC,kBAovBD,CApvBoB,QAovBpB,CAAA,EAAA,OAAA,GAAA,SAAA,CAAA,CAAA,EAnvBb,kBAmvBa,CAnvBM,QAmvBN,CAAA;;;;;;;;;;AA6DhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAnuBgB,iCAAiC,gCACnC,YACX;;;;;;;;;;;;;KAwDS,sCACO,sCACE,oBAAoB;;aAG5B;;;;;;;;;0BASa;cACZ,mBAAmB;aACpB;;;;;;;;;;;;;;;;;;;;;;;KA4BD,+BAA+B,uBAEvC,kEAEE;;;;;;;;;;;;;;;;;;;;;;KAuBM,mCAAmC,uBAAuB;;;;;;KAOjE,qEACH,eAAe,KAAK,qCAEhB,2CACE,iBAAiB,SAAS;;;;;;;;KAU7B,6DAGD,wFAEE,iBAAiB,KAAK,eACtB,4EAEI,eAAe,SAAS,6CAEtB,eAAe,SAAS,+BAGhC,6BAEE,sBACE,mDAGA,gBAAgB;;;;;;;;;;;;;;;;;;;KAsBZ,iEACV,WAAW,6BAEP,eAAe,iCAEb,eAAe,KAAK,wBAClB;;;;;;;;;;;KAaE,oDACO,sCACE,oBAAoB;;aAI5B;;;;;;;;;wDAS2C,oBAC7C,8BACM,eAAe;cAElB,mBAAmB;aACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDG,sCAAsC,6BAC1C,mCACD,oBACC,KACR,QAAQ;YAAoC;oDAG7C,qBACD,UACA,QAAQ,oBAAoB;YAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDrC,sCACG,yDAGP,mCACD;cAEK,WAAW;cACX;IAEb,qBACD,UACA,QACE,oBAAoB;YACR,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiE3B,sCACG,yDAGP,kCACD;cAEK,WAAW;cACX;IAEb,mCACD,UACA,QACE,oBAAoB;YACR,2BAA2B;IAEzC;;;;;;;;;;;KAgEU,qCACO,qCACC,mBAAmB,4BACpB;;YAGP;;WAED;;;;;;;yBAOc,6BAA6B,2BAChD,QAAQ,oBAAoB;cAAuB;OACnD,QACE,oBAAoB;cACR,2BAA2B;;;;;;;;;;;;;KAcnC,mDACO,qCACC,mBAAmB,4BACpB;;YAGP;;WAED;;;;;;;;qEASK,WAAW,0BACpB,QACH,oBAAoB;cACR,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmD3B,qCAAqC,0BAC5C,2BACG,mCACD,oBACC,KACR,QAAQ;YAAoC;oDAG7C,oBACD,UACA,mBAAmB,WACnB,QAAQ;YAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoD9B,qCAAqC,sDAC5C,2BACG,mCACD;cAEK,WAAW;cACX;IAEb,oBACD,UACA,mBAAmB,WACnB,QAAQ;YAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuD9B,qCAAqC,sDAC5C,2BACG,kCACD;cAEK,eAAe;cACf;IAEb,kCACD,UACA,mBAAmB,WACnB,QAAQ;YAAoC"}