@amqp-contract/contract 0.11.0 → 0.13.0

package/dist/index.cjs

@@ -1,5 +1,5 @@
 
-//#region src/builder.ts
+//#region src/builder/exchange.ts
 /**
 * Define an AMQP exchange.
 *
@@ -20,6 +20,263 @@ function defineExchange(name, type, options) {
 		...options
 	};
 }
+
+//#endregion
+//#region src/builder/message.ts
+/**
+* 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 defineMessage(payload, options) {
+	return {
+		payload,
+		...options
+	};
+}
+
+//#endregion
+//#region src/builder/binding.ts
+/**
+* Type guard to check if a queue entry is a QueueWithTtlBackoffInfrastructure.
+* Duplicated here to avoid circular dependency with queue.ts.
+* @internal
+*/
+function isQueueWithTtlBackoffInfrastructure$1(entry) {
+	return typeof entry === "object" && entry !== null && "__brand" in entry && entry.__brand === "QueueWithTtlBackoffInfrastructure";
+}
+/**
+* Extract the plain QueueDefinition from a QueueEntry.
+* Duplicated here to avoid circular dependency with queue.ts.
+* @internal
+*/
+function extractQueueInternal(entry) {
+	if (isQueueWithTtlBackoffInfrastructure$1(entry)) return entry.queue;
+	return entry;
+}
+/**
+* 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 or queue with infrastructure to bind
+* @param exchange - The exchange definition
+* @param options - Optional binding configuration
+* @returns A queue binding definition
+* @internal
+*/
+function defineQueueBinding(queue, exchange, options) {
+	const queueDef = extractQueueInternal(queue);
+	if (exchange.type === "fanout") return {
+		type: "queue",
+		queue: queueDef,
+		exchange,
+		...options?.arguments && { arguments: options.arguments }
+	};
+	return {
+		type: "queue",
+		queue: queueDef,
+		exchange,
+		routingKey: options?.routingKey,
+		...options?.arguments && { arguments: options.arguments }
+	};
+}
+/**
+* Internal helper to call defineQueueBinding with proper type handling.
+* Used by queue.ts to avoid circular dependency.
+* @internal
+*/
+function defineQueueBindingInternal(queue, exchange, options) {
+	if (exchange.type === "fanout") return defineQueueBinding(queue, exchange, options);
+	return defineQueueBinding(queue, exchange, options);
+}
+/**
+* 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,
+		routingKey: options?.routingKey ?? "",
+		...options?.arguments && { arguments: options.arguments }
+	};
+}
+
+//#endregion
+//#region src/builder/queue.ts
+/**
+* Resolve TTL-backoff retry options with defaults applied.
+* @internal
+*/
+function resolveTtlBackoffOptions(options) {
+	return {
+		mode: "ttl-backoff",
+		maxRetries: options?.maxRetries ?? 3,
+		initialDelayMs: options?.initialDelayMs ?? 1e3,
+		maxDelayMs: options?.maxDelayMs ?? 3e4,
+		backoffMultiplier: options?.backoffMultiplier ?? 2,
+		jitter: options?.jitter ?? true
+	};
+}
+/**
+* Type guard to check if a queue entry is a QueueWithTtlBackoffInfrastructure.
+*
+* When you configure a queue with TTL-backoff retry and a dead letter exchange,
+* `defineQueue` returns a `QueueWithTtlBackoffInfrastructure` instead of a plain
+* `QueueDefinition`. This type guard helps you distinguish between the two.
+*
+* **When to use:**
+* - When you need to check the type of a queue entry at runtime
+* - When writing generic code that handles both plain queues and infrastructure wrappers
+*
+* **Related functions:**
+* - `extractQueue()` - Use this to get the underlying queue definition from either type
+*
+* @param entry - The queue entry to check
+* @returns True if the entry is a QueueWithTtlBackoffInfrastructure, false otherwise
+*
+* @example
+* ```typescript
+* const queue = defineQueue('orders', {
+*   deadLetter: { exchange: dlx },
+*   retry: { mode: 'ttl-backoff' },
+* });
+*
+* if (isQueueWithTtlBackoffInfrastructure(queue)) {
+*   // queue has .queue, .waitQueue, .waitQueueBinding, .mainQueueRetryBinding
+*   console.log('Wait queue:', queue.waitQueue.name);
+* } else {
+*   // queue is a plain QueueDefinition
+*   console.log('Queue:', queue.name);
+* }
+* ```
+*/
+function isQueueWithTtlBackoffInfrastructure(entry) {
+	return typeof entry === "object" && entry !== null && "__brand" in entry && entry.__brand === "QueueWithTtlBackoffInfrastructure";
+}
+/**
+* Extract the plain QueueDefinition from a QueueEntry.
+*
+* **Why this function exists:**
+* When you configure a queue with TTL-backoff retry and a dead letter exchange,
+* `defineQueue` (or `defineTtlBackoffQueue`) returns a wrapper object that includes
+* the main queue, wait queue, and bindings. This function extracts the underlying
+* queue definition so you can access properties like `name`, `type`, etc.
+*
+* **When to use:**
+* - When you need to access queue properties (name, type, deadLetter, etc.)
+* - When passing a queue to functions that expect a plain QueueDefinition
+* - Works safely on both plain queues and infrastructure wrappers
+*
+* **How it works:**
+* - If the entry is a `QueueWithTtlBackoffInfrastructure`, returns `entry.queue`
+* - Otherwise, returns the entry as-is (it's already a plain QueueDefinition)
+*
+* @param entry - The queue entry (either plain QueueDefinition or QueueWithTtlBackoffInfrastructure)
+* @returns The plain QueueDefinition
+*
+* @example
+* ```typescript
+* import { defineQueue, defineTtlBackoffQueue, extractQueue } from '@amqp-contract/contract';
+*
+* // TTL-backoff queue returns a wrapper
+* const orderQueue = defineTtlBackoffQueue('orders', {
+*   deadLetterExchange: dlx,
+*   maxRetries: 3,
+* });
+*
+* // Use extractQueue to access the queue name
+* const queueName = extractQueue(orderQueue).name; // 'orders'
+*
+* // Also works safely on plain queues
+* const plainQueue = defineQueue('simple', { type: 'quorum', retry: { mode: 'quorum-native' } });
+* const plainName = extractQueue(plainQueue).name; // 'simple'
+*
+* // Access other properties
+* const queueDef = extractQueue(orderQueue);
+* console.log(queueDef.name);       // 'orders'
+* console.log(queueDef.type);       // 'quorum'
+* console.log(queueDef.deadLetter); // { exchange: dlx, ... }
+* ```
+*
+* @see isQueueWithTtlBackoffInfrastructure - Type guard to check if extraction is needed
+* @see defineTtlBackoffQueue - Creates queues with TTL-backoff infrastructure
+*/
+function extractQueue(entry) {
+	if (isQueueWithTtlBackoffInfrastructure(entry)) return entry.queue;
+	return entry;
+}
+/**
+* Wrap a queue definition with TTL-backoff retry infrastructure.
+* @internal
+*/
+function wrapWithTtlBackoffInfrastructure(queue) {
+	if (!queue.deadLetter) throw new Error(`Queue "${queue.name}" does not have a dead letter exchange configured. TTL-backoff retry requires deadLetter to be set on the queue.`);
+	const dlx = queue.deadLetter.exchange;
+	const waitQueueName = `${queue.name}-wait`;
+	const waitQueue = {
+		name: waitQueueName,
+		type: "quorum",
+		durable: queue.durable ?? true,
+		deadLetter: {
+			exchange: dlx,
+			routingKey: queue.name
+		},
+		retry: resolveTtlBackoffOptions(void 0)
+	};
+	return {
+		__brand: "QueueWithTtlBackoffInfrastructure",
+		queue,
+		waitQueue,
+		waitQueueBinding: defineQueueBindingInternal(waitQueue, dlx, { routingKey: waitQueueName }),
+		mainQueueRetryBinding: defineQueueBindingInternal(queue, dlx, { routingKey: queue.name })
+	};
+}
 /**
 * Define an AMQP queue.
 *
@@ -92,22 +349,30 @@ function defineQueue(name, options) {
 	if (opts.arguments !== void 0) baseProps.arguments = opts.arguments;
 	if (type === "quorum") {
 		const quorumOpts = opts;
+		const inputRetry = quorumOpts.retry ?? { mode: "ttl-backoff" };
+		if (inputRetry.mode === "quorum-native") {
+			if (quorumOpts.deliveryLimit === void 0) throw new Error(`Queue "${name}" uses quorum-native retry mode but deliveryLimit is not configured. Quorum-native retry requires deliveryLimit to be set.`);
+		}
+		const retry$1 = inputRetry.mode === "quorum-native" ? inputRetry : resolveTtlBackoffOptions(inputRetry);
 		const queueDefinition$1 = {
 			...baseProps,
-			type: "quorum"
+			type: "quorum",
+			retry: retry$1
 		};
 		if (quorumOpts.deliveryLimit !== void 0) {
 			if (quorumOpts.deliveryLimit < 1 || !Number.isInteger(quorumOpts.deliveryLimit)) throw new Error(`Invalid deliveryLimit: ${quorumOpts.deliveryLimit}. Must be a positive integer.`);
 			queueDefinition$1.deliveryLimit = quorumOpts.deliveryLimit;
 		}
-		if (quorumOpts.retry !== void 0) queueDefinition$1.retry = quorumOpts.retry;
-		if (quorumOpts.retry?.mode === "ttl-backoff" && queueDefinition$1.deadLetter) return wrapWithTtlBackoffInfrastructure(queueDefinition$1);
+		if (retry$1.mode === "ttl-backoff" && queueDefinition$1.deadLetter) return wrapWithTtlBackoffInfrastructure(queueDefinition$1);
 		return queueDefinition$1;
 	}
 	const classicOpts = opts;
+	if (classicOpts.retry?.mode === "quorum-native") throw new Error(`Queue "${name}" uses quorum-native retry mode but is a classic queue. Quorum-native retry requires quorum queues (type: "quorum").`);
+	const retry = resolveTtlBackoffOptions(classicOpts.retry);
 	const queueDefinition = {
 		...baseProps,
-		type: "classic"
+		type: "classic",
+		retry
 	};
 	if (classicOpts.exclusive !== void 0) queueDefinition.exclusive = classicOpts.exclusive;
 	if (classicOpts.maxPriority !== void 0) {
@@ -117,129 +382,132 @@ function defineQueue(name, options) {
 			"x-max-priority": classicOpts.maxPriority
 		};
 	}
-	if (classicOpts.retry !== void 0) queueDefinition.retry = classicOpts.retry;
-	if (classicOpts.retry?.mode === "ttl-backoff" && queueDefinition.deadLetter) return wrapWithTtlBackoffInfrastructure(queueDefinition);
+	if (retry.mode === "ttl-backoff" && queueDefinition.deadLetter) return wrapWithTtlBackoffInfrastructure(queueDefinition);
 	return queueDefinition;
 }
 /**
-* Wrap a queue definition with TTL-backoff retry infrastructure.
-* @internal
-*/
-function wrapWithTtlBackoffInfrastructure(queue) {
-	if (!queue.deadLetter) throw new Error(`Queue "${queue.name}" does not have a dead letter exchange configured. TTL-backoff retry requires deadLetter to be set on the queue.`);
-	const dlx = queue.deadLetter.exchange;
-	const waitQueueName = `${queue.name}-wait`;
-	const waitQueue = {
-		name: waitQueueName,
-		type: "quorum",
-		durable: queue.durable ?? true,
-		deadLetter: {
-			exchange: dlx,
-			routingKey: queue.name
-		}
-	};
-	return {
-		__brand: "QueueWithTtlBackoffInfrastructure",
-		queue,
-		waitQueue,
-		waitQueueBinding: callDefineQueueBinding(waitQueue, dlx, { routingKey: waitQueueName }),
-		mainQueueRetryBinding: callDefineQueueBinding(queue, dlx, { routingKey: queue.name })
-	};
-}
-/**
-* Define a message definition with payload and optional headers/metadata.
+* Create a quorum queue with quorum-native retry.
 *
-* 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.
+* This is a simplified helper that enforces best practices:
+* - Uses quorum queues (recommended for most use cases)
+* - Requires dead letter exchange for failed message handling
+* - Uses quorum-native retry mode (simpler than TTL-backoff)
 *
-* @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
+* **When to use:**
+* - You want simple, immediate retries without exponential backoff
+* - You don't need configurable delays between retries
+* - You want the simplest retry configuration
+*
+* @param name - The queue name
+* @param options - Configuration options
+* @returns A quorum queue definition with quorum-native retry
 *
 * @example
 * ```typescript
-* import { z } from 'zod';
+* const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
 *
-* 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'
-*   }
-* );
+* const orderQueue = defineQuorumQueue('order-processing', {
+*   deadLetterExchange: dlx,
+*   deliveryLimit: 3, // Retry up to 3 times
+* });
+*
+* const contract = defineContract({
+*   exchanges: { dlx },
+*   queues: { orderProcessing: orderQueue },
+*   // ...
+* });
 * ```
+*
+* @see defineQueue - For full queue configuration options
+* @see defineTtlBackoffQueue - For queues with exponential backoff retry
 */
-function defineMessage(payload, options) {
-	return {
-		payload,
-		...options
+function defineQuorumQueue(name, options) {
+	const { deadLetterExchange, deadLetterRoutingKey, deliveryLimit, autoDelete, arguments: args } = options;
+	const queueOptions = {
+		type: "quorum",
+		deadLetter: deadLetterRoutingKey ? {
+			exchange: deadLetterExchange,
+			routingKey: deadLetterRoutingKey
+		} : { exchange: deadLetterExchange },
+		deliveryLimit,
+		retry: { mode: "quorum-native" }
 	};
+	if (autoDelete !== void 0) queueOptions.autoDelete = autoDelete;
+	if (args !== void 0) queueOptions.arguments = args;
+	return defineQueue(name, queueOptions);
 }
 /**
-* Define a binding between a queue and an exchange.
+* Create a queue with TTL-backoff retry (exponential backoff).
 *
-* This is the implementation function - use the type-specific overloads for better type safety.
+* This is a simplified helper that enforces best practices:
+* - Uses quorum queues (recommended for most use cases)
+* - Requires dead letter exchange for retry routing
+* - Uses TTL-backoff retry mode with configurable delays
+* - Automatically generates wait queue and bindings
 *
-* @param queue - The queue definition or queue with infrastructure to bind
-* @param exchange - The exchange definition
-* @param options - Optional binding configuration
-* @returns A queue binding definition
-* @internal
-*/
-function defineQueueBinding(queue, exchange, options) {
-	const queueDef = extractQueue(queue);
-	if (exchange.type === "fanout") return {
-		type: "queue",
-		queue: queueDef,
-		exchange,
-		...options?.arguments && { arguments: options.arguments }
-	};
-	return {
-		type: "queue",
-		queue: queueDef,
-		exchange,
-		routingKey: options?.routingKey,
-		...options?.arguments && { arguments: options.arguments }
-	};
-}
-/**
-* Define a binding between two exchanges (exchange-to-exchange routing).
+* **When to use:**
+* - You need exponential backoff between retries
+* - You want configurable delays (initial delay, max delay, jitter)
+* - You're processing messages that may need time before retry
 *
-* This is the implementation function - use the type-specific overloads for better type safety.
+* **Returns:** A `QueueWithTtlBackoffInfrastructure` object that includes the
+* main queue, wait queue, and bindings. Pass this directly to `defineContract`
+* and it will be expanded automatically.
 *
-* @param destination - The destination exchange definition
-* @param source - The source exchange definition
-* @param options - Optional binding configuration
-* @returns An exchange binding definition
-* @internal
+* @param name - The queue name
+* @param options - Configuration options
+* @returns A queue with TTL-backoff infrastructure
+*
+* @example
+* ```typescript
+* const dlx = defineExchange('orders-dlx', 'direct', { durable: true });
+*
+* const orderQueue = defineTtlBackoffQueue('order-processing', {
+*   deadLetterExchange: dlx,
+*   maxRetries: 5,
+*   initialDelayMs: 1000,  // Start with 1s delay
+*   maxDelayMs: 30000,     // Cap at 30s
+* });
+*
+* const contract = defineContract({
+*   exchanges: { dlx },
+*   queues: { orderProcessing: orderQueue }, // Wait queue auto-added
+*   // ... bindings auto-generated
+* });
+*
+* // To access the underlying queue definition (e.g., for the queue name):
+* import { extractQueue } from '@amqp-contract/contract';
+* const queueName = extractQueue(orderQueue).name;
+* ```
+*
+* @see defineQueue - For full queue configuration options
+* @see defineQuorumQueue - For queues with quorum-native retry (simpler, immediate retries)
+* @see extractQueue - To access the underlying queue definition
 */
-function defineExchangeBinding(destination, source, options) {
-	if (source.type === "fanout") return {
-		type: "exchange",
-		source,
-		destination,
-		...options?.arguments && { arguments: options.arguments }
-	};
-	return {
-		type: "exchange",
-		source,
-		destination,
-		routingKey: options?.routingKey ?? "",
-		...options?.arguments && { arguments: options.arguments }
+function defineTtlBackoffQueue(name, options) {
+	const { deadLetterExchange, deadLetterRoutingKey, maxRetries, initialDelayMs, maxDelayMs, backoffMultiplier, jitter, autoDelete, arguments: args } = options;
+	const deadLetter = deadLetterRoutingKey ? {
+		exchange: deadLetterExchange,
+		routingKey: deadLetterRoutingKey
+	} : { exchange: deadLetterExchange };
+	const retryOptions = { mode: "ttl-backoff" };
+	if (maxRetries !== void 0) retryOptions.maxRetries = maxRetries;
+	if (initialDelayMs !== void 0) retryOptions.initialDelayMs = initialDelayMs;
+	if (maxDelayMs !== void 0) retryOptions.maxDelayMs = maxDelayMs;
+	if (backoffMultiplier !== void 0) retryOptions.backoffMultiplier = backoffMultiplier;
+	if (jitter !== void 0) retryOptions.jitter = jitter;
+	const queueOptions = {
+		type: "quorum",
+		deadLetter,
+		retry: retryOptions
 	};
+	if (autoDelete !== void 0) queueOptions.autoDelete = autoDelete;
+	if (args !== void 0) queueOptions.arguments = args;
+	return defineQueue(name, queueOptions);
 }
+
+//#endregion
+//#region src/builder/publisher.ts
 /**
 * Define a message publisher.
 *
@@ -263,6 +531,18 @@ function definePublisher(exchange, message, options) {
 	};
 }
 /**
+* Helper to call definePublisher with proper type handling.
+* Type safety is enforced by overloaded public function signatures.
+* @internal
+*/
+function definePublisherInternal(exchange, message, options) {
+	if (exchange.type === "fanout") return definePublisher(exchange, message, options);
+	return definePublisher(exchange, message, options);
+}
+
+//#endregion
+//#region src/builder/consumer.ts
+/**
 * Define a message consumer.
 *
 * A consumer receives and processes messages from a queue. The message schema is validated
@@ -271,6 +551,19 @@ function definePublisher(exchange, message, options) {
 * Consumers are associated with a specific queue and message type. When you create a worker
 * with this consumer, it will process messages from the queue according to the schema.
 *
+* **Which pattern to use:**
+*
+* | Pattern | Best for | Description |
+* |---------|----------|-------------|
+* | `definePublisher` + `defineConsumer` | Independent definition | Define publishers and consumers separately with manual schema consistency |
+* | `defineEventPublisher` + `defineEventConsumer` | Event broadcasting | Define event publisher first, create consumers that subscribe to it |
+* | `defineCommandConsumer` + `defineCommandPublisher` | Task queues | Define command consumer first, create publishers that send commands to it |
+*
+* Use `defineCommandConsumer` when:
+* - One consumer receives from multiple publishers
+* - You want automatic schema consistency between consumer and publishers
+* - You're building task queue or command patterns
+*
 * @param queue - The queue definition to consume from
 * @param message - The message definition with payload schema
 * @param options - Optional consumer configuration
@@ -303,6 +596,9 @@ function definePublisher(exchange, message, options) {
 * //   connection
 * // });
 * ```
+*
+* @see defineCommandConsumer - For task queue patterns with automatic schema consistency
+* @see defineEventPublisher - For event-driven patterns with automatic schema consistency
 */
 function defineConsumer(queue, message, options) {
 	return {
@@ -311,6 +607,99 @@ function defineConsumer(queue, message, options) {
 		...options
 	};
 }
+
+//#endregion
+//#region src/builder/event.ts
+/**
+* Implementation of defineEventPublisher.
+* @internal
+*/
+function defineEventPublisher(exchange, message, options) {
+	const config = {
+		__brand: "EventPublisherConfig",
+		exchange,
+		message,
+		routingKey: options?.routingKey
+	};
+	if (options?.arguments !== void 0) config.arguments = options.arguments;
+	return config;
+}
+/**
+* Implementation of defineEventConsumer.
+* @internal
+*/
+function defineEventConsumer(eventPublisher, queue, options) {
+	const { exchange, message, routingKey: publisherRoutingKey } = eventPublisher;
+	const bindingRoutingKey = options?.routingKey ?? publisherRoutingKey;
+	const bindingOptions = {};
+	if (bindingRoutingKey !== void 0) bindingOptions.routingKey = bindingRoutingKey;
+	const bindingArguments = options?.arguments ?? eventPublisher.arguments;
+	if (bindingArguments !== void 0) bindingOptions.arguments = bindingArguments;
+	const binding = defineQueueBindingInternal(queue, exchange, bindingOptions);
+	return {
+		__brand: "EventConsumerResult",
+		consumer: defineConsumer(queue, message),
+		binding
+	};
+}
+/**
+* Type guard to check if a value is an EventPublisherConfig.
+*
+* @param value - The value to check
+* @returns True if the value is an EventPublisherConfig
+*/
+function isEventPublisherConfig(value) {
+	return typeof value === "object" && value !== null && "__brand" in value && value.__brand === "EventPublisherConfig";
+}
+/**
+* Type guard to check if a value is an EventConsumerResult.
+*
+* @param value - The value to check
+* @returns True if the value is an EventConsumerResult
+*/
+function isEventConsumerResult(value) {
+	return typeof value === "object" && value !== null && "__brand" in value && value.__brand === "EventConsumerResult";
+}
+
+//#endregion
+//#region src/builder/command.ts
+/**
+* Implementation of defineCommandConsumer.
+* @internal
+*/
+function defineCommandConsumer(queue, exchange, message, options) {
+	return {
+		__brand: "CommandConsumerConfig",
+		consumer: defineConsumer(queue, message),
+		binding: defineQueueBindingInternal(queue, exchange, options),
+		exchange,
+		message,
+		routingKey: options?.routingKey
+	};
+}
+/**
+* Implementation of defineCommandPublisher.
+* @internal
+*/
+function defineCommandPublisher(commandConsumer, options) {
+	const { exchange, message, routingKey: consumerRoutingKey } = commandConsumer;
+	const publisherRoutingKey = options?.routingKey ?? consumerRoutingKey;
+	const publisherOptions = {};
+	if (publisherRoutingKey !== void 0) publisherOptions.routingKey = publisherRoutingKey;
+	return definePublisherInternal(exchange, message, publisherOptions);
+}
+/**
+* Type guard to check if a value is a CommandConsumerConfig.
+*
+* @param value - The value to check
+* @returns True if the value is a CommandConsumerConfig
+*/
+function isCommandConsumerConfig(value) {
+	return typeof value === "object" && value !== null && "__brand" in value && value.__brand === "CommandConsumerConfig";
+}
+
+//#endregion
+//#region src/builder/contract.ts
 /**
 * Define an AMQP contract.
 *
@@ -381,138 +770,53 @@ function defineConsumer(queue, message, options) {
 * ```
 */
 function defineContract(definition) {
-	if (!definition.queues || Object.keys(definition.queues).length === 0) return definition;
-	const queues = definition.queues;
-	const expandedQueues = {};
-	const autoBindings = {};
-	for (const [name, entry] of Object.entries(queues)) if (isQueueWithTtlBackoffInfrastructure(entry)) {
-		expandedQueues[name] = entry.queue;
-		expandedQueues[`${name}Wait`] = entry.waitQueue;
-		autoBindings[`${name}WaitBinding`] = entry.waitQueueBinding;
-		autoBindings[`${name}RetryBinding`] = entry.mainQueueRetryBinding;
-	} else expandedQueues[name] = entry;
-	if (Object.keys(autoBindings).length > 0) {
-		const mergedBindings = {
-			...definition.bindings,
-			...autoBindings
-		};
-		return {
-			...definition,
-			queues: expandedQueues,
-			bindings: mergedBindings
+	const { publishers: inputPublishers, consumers: inputConsumers, ...rest } = definition;
+	const result = rest;
+	if (definition.queues && Object.keys(definition.queues).length > 0) {
+		const expandedQueues = {};
+		const queueBindings = {};
+		for (const [name, entry] of Object.entries(definition.queues)) if (isQueueWithTtlBackoffInfrastructure(entry)) {
+			expandedQueues[name] = entry.queue;
+			expandedQueues[`${name}Wait`] = entry.waitQueue;
+			queueBindings[`${name}WaitBinding`] = entry.waitQueueBinding;
+			queueBindings[`${name}RetryBinding`] = entry.mainQueueRetryBinding;
+		} else expandedQueues[name] = entry;
+		result.queues = expandedQueues;
+		if (Object.keys(queueBindings).length > 0) result.bindings = {
+			...result.bindings,
+			...queueBindings
 		};
 	}
-	return {
-		...definition,
-		queues: expandedQueues
-	};
-}
-/**
-* Type guard to check if a queue entry is a QueueWithTtlBackoffInfrastructure.
-* @internal
-*/
-function isQueueWithTtlBackoffInfrastructure(entry) {
-	return typeof entry === "object" && entry !== null && "__brand" in entry && entry.__brand === "QueueWithTtlBackoffInfrastructure";
-}
-/**
-* Extract the plain QueueDefinition from a QueueEntry.
-* If the entry is a QueueWithTtlBackoffInfrastructure, returns the inner queue.
-* Otherwise, returns the entry as-is.
-*
-* @param entry - The queue entry (either plain QueueDefinition or QueueWithTtlBackoffInfrastructure)
-* @returns The plain QueueDefinition
-*
-* @example
-* ```typescript
-* const queue = defineQueue('orders', { retry: { mode: 'ttl-backoff' }, deadLetter: { exchange: dlx } });
-* const plainQueue = extractQueue(queue); // Returns the inner QueueDefinition
-* ```
-*/
-function extractQueue(entry) {
-	if (isQueueWithTtlBackoffInfrastructure(entry)) return entry.queue;
-	return entry;
-}
-/**
-* 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);
-	if (exchange.type === "topic") {
-		const createConsumer$1 = (queue, routingKey) => {
-			const binding = callDefineQueueBinding(queue, exchange, routingKey ? {
-				...options,
-				routingKey
-			} : options);
-			return {
-				consumer: defineConsumer(queue, message),
-				binding
-			};
-		};
-		return {
-			publisher,
-			createConsumer: createConsumer$1
-		};
+	if (inputPublishers && Object.keys(inputPublishers).length > 0) {
+		const processedPublishers = {};
+		for (const [name, entry] of Object.entries(inputPublishers)) if (isEventPublisherConfig(entry)) {
+			const publisherOptions = {};
+			if (entry.routingKey !== void 0) publisherOptions.routingKey = entry.routingKey;
+			processedPublishers[name] = definePublisherInternal(entry.exchange, entry.message, publisherOptions);
+		} else processedPublishers[name] = entry;
+		result.publishers = processedPublishers;
 	}
-	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);
-	if (exchange.type === "topic") {
-		const createPublisher$1 = (routingKey) => {
-			return callDefinePublisher(exchange, message, {
-				...options,
-				routingKey
-			});
-		};
-		return {
-			consumer,
-			binding,
-			createPublisher: createPublisher$1
+	if (inputConsumers && Object.keys(inputConsumers).length > 0) {
+		const processedConsumers = {};
+		const consumerBindings = {};
+		for (const [name, entry] of Object.entries(inputConsumers)) if (isEventConsumerResult(entry)) {
+			processedConsumers[name] = entry.consumer;
+			consumerBindings[`${name}Binding`] = entry.binding;
+		} else if (isCommandConsumerConfig(entry)) {
+			processedConsumers[name] = entry.consumer;
+			consumerBindings[`${name}Binding`] = entry.binding;
+		} else processedConsumers[name] = entry;
+		result.consumers = processedConsumers;
+		if (Object.keys(consumerBindings).length > 0) result.bindings = {
+			...result.bindings,
+			...consumerBindings
 		};
 	}
-	const createPublisher = () => {
-		return callDefinePublisher(exchange, message, options);
-	};
-	return {
-		consumer,
-		binding,
-		createPublisher
-	};
+	return result;
 }
+
+//#endregion
+//#region src/builder/ttl-backoff.ts
 /**
 * Create TTL-backoff retry infrastructure for a queue.
 *
@@ -578,21 +882,29 @@ function defineTtlBackoffRetryInfrastructure(queueEntry, options) {
 	});
 	return {
 		waitQueue,
-		waitQueueBinding: callDefineQueueBinding(waitQueue, dlx, { routingKey: waitQueueName }),
-		mainQueueRetryBinding: callDefineQueueBinding(queue, dlx, { routingKey: queue.name })
+		waitQueueBinding: defineQueueBindingInternal(waitQueue, dlx, { routingKey: waitQueueName }),
+		mainQueueRetryBinding: defineQueueBindingInternal(queue, dlx, { routingKey: queue.name })
 	};
 }
 
 //#endregion
+exports.defineCommandConsumer = defineCommandConsumer;
+exports.defineCommandPublisher = defineCommandPublisher;
 exports.defineConsumer = defineConsumer;
-exports.defineConsumerFirst = defineConsumerFirst;
 exports.defineContract = defineContract;
+exports.defineEventConsumer = defineEventConsumer;
+exports.defineEventPublisher = defineEventPublisher;
 exports.defineExchange = defineExchange;
 exports.defineExchangeBinding = defineExchangeBinding;
 exports.defineMessage = defineMessage;
 exports.definePublisher = definePublisher;
-exports.definePublisherFirst = definePublisherFirst;
 exports.defineQueue = defineQueue;
 exports.defineQueueBinding = defineQueueBinding;
+exports.defineQuorumQueue = defineQuorumQueue;
+exports.defineTtlBackoffQueue = defineTtlBackoffQueue;
 exports.defineTtlBackoffRetryInfrastructure = defineTtlBackoffRetryInfrastructure;
-exports.extractQueue = extractQueue;
+exports.extractQueue = extractQueue;
+exports.isCommandConsumerConfig = isCommandConsumerConfig;
+exports.isEventConsumerResult = isEventConsumerResult;
+exports.isEventPublisherConfig = isEventPublisherConfig;
+exports.isQueueWithTtlBackoffInfrastructure = isQueueWithTtlBackoffInfrastructure;