@amqp-contract/worker 0.20.0 → 0.22.0

package/dist/index.d.cts

@@ -1,13 +1,13 @@
-import { Logger, MessageValidationError, TechnicalError, TelemetryProvider } from "@amqp-contract/core";
+import { ConsumerDefinition, ConsumerEntry, ContractDefinition, InferConsumerNames, InferRpcNames, MessageDefinition, RpcDefinition } from "@amqp-contract/contract";
+import { ConsumerOptions as ConsumerOptions$1, Logger, MessageValidationError, TechnicalError, TelemetryProvider } from "@amqp-contract/core";
+import { Future, Result } from "@swan-io/boxed";
 import * as amqp from "amqplib";
 import { ConsumeMessage } from "amqplib";
 import { TcpSocketConnectOpts } from "net";
 import { ConnectionOptions } from "tls";
-import { ConsumerDefinition, ConsumerEntry, ContractDefinition, InferConsumerNames, MessageDefinition } from "@amqp-contract/contract";
-import { Future, Result } from "@swan-io/boxed";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region ../../node_modules/.pnpm/amqp-connection-manager@5.0.0_amqplib@0.10.9/node_modules/amqp-connection-manager/dist/types/AmqpConnectionManager.d.ts
+//#region ../../node_modules/.pnpm/amqp-connection-manager@5.0.0_amqplib@1.0.3/node_modules/amqp-connection-manager/dist/types/AmqpConnectionManager.d.ts
 type ConnectionUrl = string | amqp.Options.Connect | {
   url: string;
   connectionOptions?: AmqpConnectionOptions;
@@ -196,9 +196,9 @@ declare function nonRetryable(message: string, cause?: unknown): NonRetryableErr
 //#endregion
 //#region src/types.d.ts
 /**
- * Infer the TypeScript type from a schema
+ * Infer the output type from a schema (used by consumers after validation)
  */
-type InferSchemaInput<TSchema extends StandardSchemaV1> = TSchema extends StandardSchemaV1<infer TInput> ? TInput : never;
+type InferSchemaOutput<TSchema extends StandardSchemaV1> = TSchema extends StandardSchemaV1<infer _TInput, infer TOutput> ? TOutput : never;
 /**
  * Extract the ConsumerDefinition from any consumer entry type.
  * Handles ConsumerDefinition, EventConsumerResult, and CommandConsumerConfig.
@@ -207,32 +207,42 @@ type ExtractConsumerDefinition<T extends ConsumerEntry> = T extends ConsumerDefi
   consumer: ConsumerDefinition;
 } ? T["consumer"] : never;
 /**
- * Infer consumer message payload input type.
+ * Infer consumer message payload output type.
  * Works with any consumer entry type by first extracting the ConsumerDefinition.
  */
-type ConsumerInferPayloadInput<TConsumer extends ConsumerEntry> = ExtractConsumerDefinition<TConsumer> extends ConsumerDefinition ? InferSchemaInput<ExtractConsumerDefinition<TConsumer>["message"]["payload"]> : never;
+type ConsumerInferPayloadOutput<TConsumer extends ConsumerEntry> = ExtractConsumerDefinition<TConsumer> extends ConsumerDefinition ? InferSchemaOutput<ExtractConsumerDefinition<TConsumer>["message"]["payload"]> : never;
 /**
- * Infer consumer message headers input type
- * Returns undefined if no headers schema is defined
+ * Infer consumer message headers output type.
+ * Returns undefined if no headers schema is defined.
  */
-type ConsumerInferHeadersInput<TConsumer extends ConsumerEntry> = ExtractConsumerDefinition<TConsumer> extends ConsumerDefinition ? ExtractConsumerDefinition<TConsumer>["message"] extends MessageDefinition<infer _TPayload, infer THeaders> ? THeaders extends StandardSchemaV1<Record<string, unknown>> ? InferSchemaInput<THeaders> : undefined : undefined : undefined;
+type ConsumerInferHeadersOutput<TConsumer extends ConsumerEntry> = ExtractConsumerDefinition<TConsumer> extends ConsumerDefinition ? ExtractConsumerDefinition<TConsumer>["message"] extends MessageDefinition<infer _TPayload, infer THeaders> ? THeaders extends StandardSchemaV1<Record<string, unknown>> ? InferSchemaOutput<THeaders> : undefined : undefined : undefined;
+type InferConsumers<TContract extends ContractDefinition> = NonNullable<TContract["consumers"]>;
+type InferConsumer<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = InferConsumers<TContract>[TName];
+type InferRpcs<TContract extends ContractDefinition> = NonNullable<TContract["rpcs"]>;
+type InferRpc<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = InferRpcs<TContract>[TName];
 /**
- * Infer all consumers from contract
+ * Infer the payload type for a regular consumer (validated against the message schema).
  */
-type InferConsumers<TContract extends ContractDefinition> = NonNullable<TContract["consumers"]>;
+type WorkerInferConsumerPayload<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = ConsumerInferPayloadOutput<InferConsumer<TContract, TName>>;
 /**
- * Get specific consumer entry from contract
+ * Infer the headers type for a regular consumer.
+ * Returns undefined if no headers schema is defined.
  */
-type InferConsumer<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = InferConsumers<TContract>[TName];
+type WorkerInferConsumerHeaders<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = ConsumerInferHeadersOutput<InferConsumer<TContract, TName>>;
+/**
+ * Infer the request payload type for an RPC.
+ */
+type WorkerInferRpcRequest<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = InferRpc<TContract, TName> extends RpcDefinition<infer TRequest, MessageDefinition> ? TRequest extends MessageDefinition ? InferSchemaOutput<TRequest["payload"]> : never : never;
 /**
- * Infer the payload type for a specific consumer
+ * Infer the request headers type for an RPC. Returns undefined unless the RPC's
+ * request `MessageDefinition` declares a headers schema.
  */
-type WorkerInferConsumerPayload<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = ConsumerInferPayloadInput<InferConsumer<TContract, TName>>;
+type WorkerInferRpcHeaders<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = InferRpc<TContract, TName> extends RpcDefinition<infer TRequest, MessageDefinition> ? TRequest extends MessageDefinition<infer _TPayload, infer THeaders> ? THeaders extends StandardSchemaV1<Record<string, unknown>> ? InferSchemaOutput<THeaders> : undefined : undefined : undefined;
 /**
- * Infer the headers type for a specific consumer
- * Returns undefined if no headers schema is defined
+ * Infer the response payload type for an RPC. The handler must return a
+ * `Future<Result<TResponse, HandlerError>>` matching this shape.
  */
-type WorkerInferConsumerHeaders<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = ConsumerInferHeadersInput<InferConsumer<TContract, TName>>;
+type WorkerInferRpcResponse<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = InferRpc<TContract, TName> extends RpcDefinition<MessageDefinition, infer TResponse> ? TResponse extends MessageDefinition ? InferSchemaOutput<TResponse["payload"]> : never : never;
 /**
  * A consumed message containing parsed payload and headers.
  *
@@ -244,7 +254,6 @@ type WorkerInferConsumerHeaders<TContract extends ContractDefinition, TName exte
  *
  * @example
  * ```typescript
- * // Handler receives the consumed message with typed payload and headers
  * const handler = defineHandler(contract, 'processOrder', (message, rawMessage) => {
  *   console.log(message.payload.orderId);  // Typed payload
  *   console.log(message.headers?.priority); // Typed headers (if defined)
@@ -258,65 +267,60 @@ type WorkerConsumedMessage<TPayload, THeaders = undefined> = {
   headers: THeaders extends undefined ? undefined : THeaders;
 };
 /**
- * Infer the full consumed message type for a specific consumer.
- * Includes both payload and headers (if defined).
+ * Infer the full consumed message type for a regular consumer.
  */
 type WorkerInferConsumedMessage<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = WorkerConsumedMessage<WorkerInferConsumerPayload<TContract, TName>, WorkerInferConsumerHeaders<TContract, TName>>;
 /**
- * Consumer handler type for a specific consumer.
- * Returns a `Future<Result<void, HandlerError>>` for explicit error handling.
- *
- * Error handling:
- * - RetryableError: Message will be retried with exponential backoff
- * - NonRetryableError: Message will be immediately sent to DLQ
- *
- * The `WorkerInfer*` naming pattern indicates type inference helpers that extract
- * types from a contract definition at compile time.
- *
- * @param message - The parsed message containing validated payload and headers
- * @param rawMessage - The raw AMQP message with all metadata (fields, properties, content)
- *
- * @example
- * ```typescript
- * const handler: WorkerInferConsumerHandler<typeof contract, 'processOrder'> =
- *   ({ payload }, rawMessage) => {
- *     console.log(payload.orderId);  // Typed payload
- *     console.log(rawMessage.fields.deliveryTag); // Raw AMQP message
- *     return Future.value(Result.Ok(undefined));
- *   };
- * ```
+ * Infer the consumed message type for an RPC handler — payload + headers from
+ * the request side of the RPC.
+ */
+type WorkerInferRpcConsumedMessage<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = WorkerConsumedMessage<WorkerInferRpcRequest<TContract, TName>, WorkerInferRpcHeaders<TContract, TName>>;
+/**
+ * Handler signature for a regular consumer (event/command). Returns
+ * `Future<Result<void, HandlerError>>` — there is no response message.
  */
 type WorkerInferConsumerHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = (message: WorkerInferConsumedMessage<TContract, TName>, rawMessage: ConsumeMessage) => Future<Result<void, HandlerError>>;
 /**
- * Handler entry for a consumer - either a function or a tuple of [handler, options].
- *
- * Two patterns are supported:
- * 1. Simple handler: `({ payload }, rawMessage) => Future.value(Result.Ok(undefined))`
- * 2. Handler with prefetch: `[({ payload }, rawMessage) => ..., { prefetch: 10 }]`
- *
- * Note: Retry configuration is now defined at the queue level in the contract,
- * not at the handler level. See `QueueDefinition.retry` for configuration options.
+ * Handler signature for an RPC. Returns
+ * `Future<Result<TResponse, HandlerError>>` where `TResponse` is the inferred
+ * response payload. The worker validates the response against the RPC's
+ * response schema and publishes it back to `msg.properties.replyTo` with the
+ * same `correlationId`.
  */
-type WorkerInferConsumerHandlerEntry<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = WorkerInferConsumerHandler<TContract, TName> | readonly [WorkerInferConsumerHandler<TContract, TName>, {
-  prefetch?: number;
-}];
+type WorkerInferRpcHandler<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = (message: WorkerInferRpcConsumedMessage<TContract, TName>, rawMessage: ConsumeMessage) => Future<Result<WorkerInferRpcResponse<TContract, TName>, HandlerError>>;
 /**
- * Consumer handlers for a contract.
- * All handlers return `Future<Result<void, HandlerError>>` for explicit error control.
+ * Handler entry for a regular consumer — function or `[handler, options]`.
+ */
+type WorkerInferConsumerHandlerEntry<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>> = WorkerInferConsumerHandler<TContract, TName> | readonly [WorkerInferConsumerHandler<TContract, TName>, ConsumerOptions];
+/**
+ * Handler entry for an RPC — function or `[handler, options]`.
+ */
+type WorkerInferRpcHandlerEntry<TContract extends ContractDefinition, TName extends InferRpcNames<TContract>> = WorkerInferRpcHandler<TContract, TName> | readonly [WorkerInferRpcHandler<TContract, TName>, ConsumerOptions];
+/**
+ * All handlers for a contract: one entry per `consumers` key plus one entry
+ * per `rpcs` key. The two name spaces are disjoint so the resulting object
+ * type is unambiguous.
  *
  * @example
  * ```typescript
- * const handlers: WorkerInferConsumerHandlers<typeof contract> = {
+ * const handlers: WorkerInferHandlers<typeof contract> = {
  *   processOrder: ({ payload }) =>
  *     Future.fromPromise(processPayment(payload))
  *       .mapOk(() => undefined)
  *       .mapError((error) => new RetryableError('Payment failed', error)),
+ *   calculate: ({ payload }) =>
+ *     Future.value(Result.Ok({ sum: payload.a + payload.b })),
  * };
  * ```
  */
-type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = { [K in InferConsumerNames<TContract>]: WorkerInferConsumerHandlerEntry<TContract, K> };
+type WorkerInferHandlers<TContract extends ContractDefinition> = ([InferConsumerNames<TContract>] extends [never] ? {} : { [K in InferConsumerNames<TContract>]: WorkerInferConsumerHandlerEntry<TContract, K> }) & ([InferRpcNames<TContract>] extends [never] ? {} : { [K in InferRpcNames<TContract>]: WorkerInferRpcHandlerEntry<TContract, K> });
+/**
+ * @deprecated Use `WorkerInferHandlers` — handlers now span consumers ∪ rpcs.
+ */
+type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = WorkerInferHandlers<TContract>;
 //#endregion
 //#region src/worker.d.ts
+type ConsumerOptions = ConsumerOptions$1;
 /**
  * Options for creating a type-safe AMQP worker.
  *
@@ -342,6 +346,9 @@ type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = { [K in
  *     ]
  *   },
  *   urls: ['amqp://localhost'],
+ *   defaultConsumerOptions: {
+ *     prefetch: 5,
+ *   },
  *   connectionOptions: {
  *     heartbeatIntervalInSeconds: 30
  *   },
@@ -355,11 +362,16 @@ type WorkerInferConsumerHandlers<TContract extends ContractDefinition> = { [K in
 type CreateWorkerOptions<TContract extends ContractDefinition> = {
   /** The AMQP contract definition specifying consumers and their message schemas */contract: TContract;
   /**
-   * Handlers for each consumer defined in the contract.
-   * Handlers must return `Future<Result<void, HandlerError>>` for explicit error handling.
-   * Use defineHandler() to create handlers.
+   * Handlers for each `consumers` and `rpcs` entry in the contract.
+   *
+   * - Regular consumers return `Future<Result<void, HandlerError>>`.
+   * - RPC handlers return `Future<Result<TResponse, HandlerError>>` where
+   *   `TResponse` is inferred from the RPC's response message schema.
+   *
+   * Use `defineHandler` / `defineHandlers` to create handlers with full type
+   * inference.
    */
-  handlers: WorkerInferConsumerHandlers<TContract>; /** AMQP broker URL(s). Multiple URLs provide failover support */
+  handlers: WorkerInferHandlers<TContract>; /** AMQP broker URL(s). Multiple URLs provide failover support */
   urls: ConnectionUrl[]; /** Optional connection configuration (heartbeat, reconnect settings, etc.) */
   connectionOptions?: AmqpConnectionManagerOptions | undefined; /** Optional logger for logging message consumption and errors */
   logger?: Logger | undefined;
@@ -369,6 +381,18 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
    * OpenTelemetry instrumentation is automatically enabled if @opentelemetry/api is installed.
    */
   telemetry?: TelemetryProvider | undefined;
+  /**
+   * Optional default consumer options applied to all consumer handlers.
+   * Handler-specific options provided in tuple form override these defaults.
+   */
+  defaultConsumerOptions?: ConsumerOptions | undefined;
+  /**
+   * Maximum time in ms to wait for the AMQP connection to become ready before
+   * `create()` resolves to `Result.Error<TechnicalError>`. Without this option,
+   * `create()` waits forever — the underlying amqp-connection-manager retries
+   * indefinitely.
+   */
+  connectTimeoutMs?: number | undefined;
 };
 /**
  * Type-safe AMQP worker for consuming messages from RabbitMQ.
@@ -384,7 +408,7 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
  * import { defineQueue, defineMessage, defineContract, defineConsumer } from '@amqp-contract/contract';
  * import { z } from 'zod';
  *
- * const orderQueue = defineQueue('order-processing', { durable: true });
+ * const orderQueue = defineQueue('order-processing');
  * const orderMessage = defineMessage(z.object({
  *   orderId: z.string(),
  *   amount: z.number()
@@ -414,15 +438,27 @@ type CreateWorkerOptions<TContract extends ContractDefinition> = {
 declare class TypedAmqpWorker<TContract extends ContractDefinition> {
   private readonly contract;
   private readonly amqpClient;
+  private readonly defaultConsumerOptions;
   private readonly logger?;
   /**
-   * Internal handler storage - handlers returning `Future<Result>`.
+   * Internal handler storage. Keyed by handler name (consumer or RPC); the
+   * stored function signature is widened so the dispatch loop can call it
+   * uniformly. The actual handler is type-checked at the worker's public API
+   * boundary via `WorkerInferHandlers<TContract>`.
    */
   private readonly actualHandlers;
   private readonly consumerOptions;
   private readonly consumerTags;
   private readonly telemetry;
   private constructor();
+  /**
+   * Build a `ConsumerDefinition`-shaped view for a handler name, regardless
+   * of whether it came from `contract.consumers` or `contract.rpcs`. The
+   * dispatch path treats both uniformly; the returned `isRpc` flag (and the
+   * accompanying `responseSchema`) tells `processMessage` whether to validate
+   * the handler return value and publish a reply.
+   */
+  private resolveConsumerView;
   /**
    * Create a type-safe AMQP worker from a contract.
    *
@@ -453,8 +489,10 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
     handlers,
     urls,
     connectionOptions,
+    defaultConsumerOptions,
     logger,
-    telemetry
+    telemetry,
+    connectTimeoutMs
   }: CreateWorkerOptions<TContract>): Future<Result<TypedAmqpWorker<TContract>, TechnicalError>>;
   /**
    * Close the AMQP channel and connection.
@@ -474,19 +512,13 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    */
   close(): Future<Result<void, TechnicalError>>;
   /**
-   * Get the retry configuration for a consumer's queue.
-   * Defaults are applied in the contract's defineQueue, so we just return the config.
-   */
-  private getRetryConfigForConsumer;
-  /**
-   * Start consuming messages for all consumers.
-   * TypeScript guarantees consumers exist (handlers require matching consumers).
+   * Start consuming for every entry in `contract.consumers` and `contract.rpcs`.
    */
   private consumeAll;
   private waitForConnectionReady;
   /**
-   * Start consuming messages for a specific consumer.
-   * TypeScript guarantees consumer and handler exist for valid consumer names.
+   * Start consuming messages for a specific handler — either a `consumers`
+   * entry (regular event/command consumer) or an `rpcs` entry (RPC server).
    */
   private consume;
   /**
@@ -499,81 +531,25 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
    */
   private parseAndValidateMessage;
   /**
-   * Consume messages one at a time
-   */
-  private consumeSingle;
-  /**
-   * Handle error in message processing with retry logic.
-   *
-   * Flow depends on retry mode:
-   *
-   * **quorum-native mode:**
-   * 1. If NonRetryableError -> send directly to DLQ (no retry)
-   * 2. Otherwise -> nack with requeue=true (RabbitMQ handles delivery count)
-   *
-   * **ttl-backoff mode:**
-   * 1. If NonRetryableError -> send directly to DLQ (no retry)
-   * 2. If max retries exceeded -> send to DLQ
-   * 3. Otherwise -> publish to wait queue with TTL for retry
-   *
-   * **Legacy mode (no retry config):**
-   * 1. nack with requeue=true (immediate requeue)
-   */
-  private handleError;
-  /**
-   * Handle error using quorum queue's native delivery limit feature.
-   *
-   * Simply requeues the message with nack(requeue=true). RabbitMQ automatically:
-   * - Increments x-delivery-count header
-   * - Dead-letters the message when count exceeds x-delivery-limit
+   * Validate an RPC handler's response and publish it back to the caller's reply
+   * queue with the same `correlationId`. Published via the AMQP default exchange
+   * with `routingKey = msg.properties.replyTo`, which works for both
+   * `amq.rabbitmq.reply-to` and any anonymous queue declared by the caller.
    *
-   * This is simpler than TTL-based retry but provides immediate retries only.
-   */
-  private handleErrorQuorumNative;
-  /**
-   * Handle error using TTL + wait queue pattern for exponential backoff.
-   */
-  private handleErrorTtlBackoff;
-  /**
-   * Calculate retry delay with exponential backoff and optional jitter.
+   * Validation errors are surfaced as NonRetryableError (handler returned the
+   * wrong shape — retrying the same input will not fix it). Publish errors are
+   * surfaced as RetryableError so the worker's existing retry logic applies.
    */
-  private calculateRetryDelay;
+  private publishRpcResponse;
   /**
-   * Parse message content for republishing.
-   * Prevents double JSON serialization by converting Buffer to object when possible.
+   * Process a single consumed message: validate, invoke handler, optionally
+   * publish the RPC response, record telemetry, and handle errors.
    */
-  private parseMessageContentForRetry;
+  private processMessage;
   /**
-   * Publish message to wait queue for retry after TTL expires.
-   *
-   * ┌─────────────────────────────────────────────────────────────────┐
-   * │ Retry Flow (Native RabbitMQ TTL + DLX Pattern)                   │
-   * ├─────────────────────────────────────────────────────────────────┤
-   * │                                                                   │
-   * │ 1. Handler throws any Error                                      │
-   * │    ↓                                                              │
-   * │ 2. Worker publishes to DLX with routing key: {queue}-wait        │
-   * │    ↓                                                              │
-   * │ 3. DLX routes to wait queue: {queue}-wait                        │
-   * │    (with expiration: calculated backoff delay)                   │
-   * │    ↓                                                              │
-   * │ 4. Message waits in queue until TTL expires                      │
-   * │    ↓                                                              │
-   * │ 5. Expired message dead-lettered to DLX                          │
-   * │    (with routing key: {queue})                                   │
-   * │    ↓                                                              │
-   * │ 6. DLX routes back to main queue → RETRY                         │
-   * │    ↓                                                              │
-   * │ 7. If retries exhausted: nack without requeue → DLQ              │
-   * │                                                                   │
-   * └─────────────────────────────────────────────────────────────────┘
+   * Consume messages one at a time.
    */
-  private publishForRetry;
-  /**
-   * Send message to dead letter queue.
-   * Nacks the message without requeue, relying on DLX configuration.
-   */
-  private sendToDLQ;
+  private consumeSingle;
 }
 //#endregion
 //#region src/handlers.d.ts
@@ -626,9 +602,7 @@ declare class TypedAmqpWorker<TContract extends ContractDefinition> {
  * ```
  */
 declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>): WorkerInferConsumerHandlerEntry<TContract, TName>;
-declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>, options: {
-  prefetch?: number;
-}): WorkerInferConsumerHandlerEntry<TContract, TName>;
+declare function defineHandler<TContract extends ContractDefinition, TName extends InferConsumerNames<TContract>>(contract: TContract, consumerName: TName, handler: WorkerInferConsumerHandler<TContract, TName>, options: ConsumerOptions): WorkerInferConsumerHandlerEntry<TContract, TName>;
 /**
  * Define multiple type-safe handlers for consumers in a contract.
  *
@@ -660,5 +634,5 @@ declare function defineHandler<TContract extends ContractDefinition, TName exten
  */
 declare function defineHandlers<TContract extends ContractDefinition>(contract: TContract, handlers: WorkerInferConsumerHandlers<TContract>): WorkerInferConsumerHandlers<TContract>;
 //#endregion
-export { type CreateWorkerOptions, type HandlerError, MessageValidationError, NonRetryableError, RetryableError, TypedAmqpWorker, type WorkerConsumedMessage, type WorkerInferConsumedMessage, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlerEntry, type WorkerInferConsumerHandlers, type WorkerInferConsumerHeaders, defineHandler, defineHandlers, isHandlerError, isNonRetryableError, isRetryableError, nonRetryable, retryable };
+export { type ConsumerOptions, type CreateWorkerOptions, type HandlerError, MessageValidationError, NonRetryableError, RetryableError, TypedAmqpWorker, type WorkerConsumedMessage, type WorkerInferConsumedMessage, type WorkerInferConsumerHandler, type WorkerInferConsumerHandlerEntry, type WorkerInferConsumerHandlers, type WorkerInferConsumerHeaders, defineHandler, defineHandlers, isHandlerError, isNonRetryableError, isRetryableError, nonRetryable, retryable };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["amqp","EventEmitter","TcpSocketConnectOpts","ConnectionOptions","ChannelWrapper","CreateChannelOpts","ConnectionUrl","Options","Connect","AmqpConnectionOptions","url","connectionOptions","ConnectListener","Connection","connection","arg","ConnectFailedListener","Error","err","Buffer","noDelay","timeout","keepAlive","keepAliveDelay","clientProperties","credentials","mechanism","username","password","response","AmqpConnectionManagerOptions","Promise","heartbeatIntervalInSeconds","reconnectTimeInSeconds","findServers","urls","callback","IAmqpConnectionManager","Function","ChannelModel","addListener","event","args","listener","reason","listeners","eventName","on","once","prependListener","prependOnceListener","removeListener","connect","options","reconnect","createChannel","close","isConnected","channelCount","AmqpConnectionManager","_channels","_currentUrl","_closed","_cancelRetriesHandler","_connectPromise","_currentConnection","_findServers","_urls","constructor","_connect","default"],"sources":["../../../node_modules/.pnpm/amqp-connection-manager@5.0.0_amqplib@0.10.9/node_modules/amqp-connection-manager/dist/types/AmqpConnectionManager.d.ts","../src/errors.ts","../src/types.ts","../src/worker.ts","../src/handlers.ts"],"x_google_ignoreList":[0],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":["amqp","EventEmitter","TcpSocketConnectOpts","ConnectionOptions","ChannelWrapper","CreateChannelOpts","ConnectionUrl","Options","Connect","AmqpConnectionOptions","url","connectionOptions","ConnectListener","Connection","connection","arg","ConnectFailedListener","Error","err","Buffer","noDelay","timeout","keepAlive","keepAliveDelay","clientProperties","credentials","mechanism","username","password","response","AmqpConnectionManagerOptions","Promise","heartbeatIntervalInSeconds","reconnectTimeInSeconds","findServers","urls","callback","IAmqpConnectionManager","Function","ChannelModel","addListener","event","args","listener","reason","listeners","eventName","on","once","prependListener","prependOnceListener","removeListener","connect","options","reconnect","createChannel","close","isConnected","channelCount","AmqpConnectionManager","_channels","_currentUrl","_closed","_cancelRetriesHandler","_connectPromise","_currentConnection","_findServers","_urls","constructor","_connect","default"],"sources":["../../../node_modules/.pnpm/amqp-connection-manager@5.0.0_amqplib@1.0.3/node_modules/amqp-connection-manager/dist/types/AmqpConnectionManager.d.ts","../src/errors.ts","../src/types.ts","../src/worker.ts","../src/handlers.ts"],"x_google_ignoreList":[0],"mappings":"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"}