@autofleet/rabbit 5.1.0-alpha.0 → 5.1.0-alpha.2

package/README.md

@@ -1,474 +1,8 @@
-# @autofleet/rabbit
+# V5 migration
 
-RabbitMQ wrapper for Autofleet microservices with support for both classic and quorum queues.
-
-## Features
-
-- **Dual Queue Support**: Classic and quorum queues with automatic vhost separation
-- **Connection Pooling**: Efficient vhost-based connection management
-- **Graceful Shutdown**: Proper cleanup of consumers and connections
-- **Redis Integration**: Message locking and timestamp validation
-- **Tracing Support**: Integration with @autofleet/zehut for distributed tracing
-- **TypeScript**: Full type safety with TypeScript definitions
-
-## Installation
-
-```bash
-pnpm add @autofleet/rabbit
-```
-
-## Quick Start
-
-```typescript
-import RabbitMq from '@autofleet/rabbit';
-
-// Initialize with optional Redis config
-const rabbit = new RabbitMq({
-  rabbitHost: 'localhost:5672',
-  logger: yourLogger,
-}, redisConfig);
-
-// Configure which queues should use quorum type
-process.env.QUORUM_QUEUES = 'order-events,user-updates,notifications';
-
-// Send to queue (automatically routes to correct vhost)
-await rabbit.sendToQueue('order-events', { orderId: 123 });
-
-// Consume from queue
-await rabbit.consume('order-events', async (msg, ack, nack) => {
-  console.log('Received:', msg.content);
-  await ack();
-});
-
-// Publish to exchange
-await rabbit.publish('events', { type: 'order.created' });
-
-// Consume from exchange
-await rabbit.consumeFromExchange('order-queue', 'events', async (msg, ack, nack) => {
-  console.log('Received:', msg.content);
-  await ack();
-});
-```
-
-## Configuration
-
-### Environment Variables
-
-- **`QUORUM_QUEUES`**: Comma-separated list of queue names that should use quorum type
-  ```bash
-  QUORUM_QUEUES="order-events,user-updates,notifications"
-  ```
-  - Queues in this list will be created in the `quorum-vhost` vhost with `x-queue-type: quorum`
-  - All other queues will use the default vhost with `x-queue-type: classic`
-
-- **`RABBITMQ_USERNAME`**: RabbitMQ username (default: `guest`)
-- **`RABBITMQ_PASSWORD`**: RabbitMQ password (default: `guest`)
-- **`RABBITMQ_SERVICE_HOST`**: RabbitMQ host (default: `localhost`)
-
-### Constructor Options
-
-```typescript
-interface AfRabbitOptions {
-  rabbitHost?: string;           // RabbitMQ host:port
-  vhost?: string;                // Default vhost name (default: 'quorum-vhost')
-  logger?: LoggerInstanceManager; // Custom logger instance
-  disableReconnect?: boolean;    // Disable automatic reconnection
-  dontGracefulShutdown?: boolean; // Disable graceful shutdown handlers
-  dontRetryAssert?: boolean;     // Don't retry on queue assertion errors
-}
-```
-
-## API Reference
-
-### Publishing
-
-#### `sendToQueue(queue: string, content: any, options?: Options.AssertQueue, customHeaders?: PublishOptions['headers'])`
-
-Send a message to a specific queue. The queue type (classic/quorum) is determined automatically based on the queue name.
-
-```typescript
-await rabbit.sendToQueue('order-events', { orderId: 123 }, {
-  durable: true,
-  messageTtl: 60000,
-}, {
-  customHeader: 'value',
-});
-```
-
-#### `publish(exchange: string, content: any, customHeaders?: PublishOptions['headers'])`
-
-Publish a message to an exchange.
-
-```typescript
-await rabbit.publish('events', { type: 'order.created' });
-```
-
-### Consuming
-
-#### `consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions)`
-
-Consume messages from a queue.
-
-```typescript
-await rabbit.consume('order-events', async (msg, ack, nack) => {
-  try {
-    await processOrder(msg.content);
-    await ack(); // Acknowledge message
-  } catch (error) {
-    await nack(msg, { skipRetry: false }); // Retry the message
-  }
-}, {
-  retries: 3,
-  deadMessageTtl: 86400000, // 24 hours
-  limit: 10, // Prefetch limit
-});
-```
-
-##### Consume Options
-
-```typescript
-interface ConsumeOptions {
-  retries?: number;              // Number of retries before sending to dead queue
-  deadMessageTtl?: number;       // TTL for dead queue messages (ms)
-  messageTtl?: number;           // TTL for messages (ms)
-  limit?: number;                // Prefetch limit
-  lockTimeout?: number;          // Redis lock timeout (ms)
-  useConsumeWithLock?: boolean;  // Enable Redis-based locking
-  auditContext?: any;            // Audit context function
-  enableRabbitTrace?: boolean;   // Enable tracing integration
-}
-```
-
-#### `consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions)`
-
-Consume messages from an exchange by binding a queue to it.
-
-```typescript
-await rabbit.consumeFromExchange('order-queue', 'events', async (msg, ack, nack) => {
-  console.log('Event:', msg.content);
-  await ack();
-});
-```
-
-### Queue Management
-
-#### `assertQueue(queueName: string, options?: Options.AssertQueue)`
-
-Assert a queue exists, creating it if necessary. Queue type is determined automatically.
-
-```typescript
-await rabbit.assertQueue('order-events', {
-  durable: true,
-  arguments: {
-    'x-message-ttl': 60000,
-  },
-});
-```
-
-#### `assertExchange(exchangeName: string, vhost?: string)`
-
-Assert an exchange exists, creating it if necessary.
-
-```typescript
-await rabbit.assertExchange('events');
-```
-
-#### `bindQueue(queue: string, exchange: string)`
-
-Bind a queue to an exchange.
-
-```typescript
-await rabbit.bindQueue('order-queue', 'events');
-```
-
-#### `getQueueLength(queue: string)`
-
-Get the number of messages in a queue.
-
-```typescript
-const { messageCount } = await rabbit.getQueueLength('order-events');
-console.log(`Queue has ${messageCount} messages`);
-```
-
-### Connection Management
-
-#### `isConnected()`
-
-Check if all connections are healthy and all consumers are registered.
-
-```typescript
-const healthy = await rabbit.isConnected();
-```
-
-#### `gracefulShutdown(signal: string)`
-
-Gracefully shutdown all connections and consumers. This is automatically called on `SIGTERM` and `SIGINT` unless `dontGracefulShutdown` is set.
-
-```typescript
-await rabbit.gracefulShutdown('SIGTERM');
-```
-
-## Architecture
-
-### Queue Type Determination
-
-Queues are automatically routed to the appropriate vhost based on the `QUORUM_QUEUES` environment variable:
-
-```typescript
-// Environment
-QUORUM_QUEUES="order-events,user-updates"
-
-// Routing
-sendToQueue('order-events', data)    → quorum-vhost (quorum queue)
-sendToQueue('other-queue', data)     → default vhost (classic queue)
-```
-
-### Connection Pooling
-
-The package maintains separate connection pools for each vhost:
-
-- **Publish connections**: One connection per vhost for publishing
-- **Consume connections**: One connection per vhost for consuming
-- **Channels**: One channel per vhost for publishing
-
-This architecture ensures efficient connection reuse while maintaining proper isolation between queue types.
-
-### Message Headers
-
-All published messages automatically include the following headers:
-
-- `creationTimestamp`: Unix timestamp in milliseconds
-- `x-user-id`: User ID from zehut context (if available)
-- `x-contexts-ids`: User context IDs from zehut (if available)
-- `x-tracing-id`: Trace ID from zehut context (if available)
-
-### Dead Letter Queues
-
-When a message exceeds the retry limit, it's automatically sent to a dead letter queue:
-
-- **Queue name**: `{original-queue}-dead`
-- **TTL**: Configurable via `deadMessageTtl` option (default: from `messageTtl`)
-
-## Migration Guides
-
-### V6 Migration (Quorum Queue Refactoring)
-
-**Version 6.0.0** introduces a cleaner architecture for managing classic and quorum queues with **breaking changes**.
-
-#### Breaking Changes
-
-1. **Removed parameters**:
-   ```typescript
-   // ❌ Old (deprecated)
-   await rabbit.sendToQueue(queue, data, options, headers, true); // isQuorumQueue param
-   await rabbit.publish(exchange, data, headers, true); // isQuorumQueue param
-
-   // ✅ New
-   await rabbit.sendToQueue(queue, data, options, headers);
-   await rabbit.publish(exchange, data, headers);
-   ```
-
-2. **Removed methods**:
-   - `assertChannel()` - Use `assertChannelForVhost(vhost)` instead (internal use only)
-
-3. **Updated method signatures**:
-   ```typescript
-   // ❌ Old
-   await rabbit.assertExchange(exchange, connectionData);
-
-   // ✅ New
-   await rabbit.assertExchange(exchange); // vhost optional, defaults to ''
-   ```
-
-4. **Removed environment variables**:
-   - `DISABLE_QUORUM_QUEUES_CONSUME` - No longer needed
-   - `DISABLE_QUORUM_QUEUES_PUBLISH` - No longer needed
-
-5. **Removed type options**:
-   ```typescript
-   // ❌ Old (deprecated)
-   interface ConsumeOptions {
-     isQuorumQueue?: boolean; // REMOVED
-   }
-   ```
-
-#### Migration Steps
-
-**Step 1**: Update your code to remove `isQuorumQueue` parameters
-
-```typescript
-// Before
-await rabbit.sendToQueue('orders', data, options, headers, true);
-
-// After
-await rabbit.sendToQueue('orders', data, options, headers);
-```
-
-**Step 2**: Configure `QUORUM_QUEUES` environment variable
-
-```bash
-# Add to your environment
-QUORUM_QUEUES="orders,events,notifications"
-```
-
-**Step 3**: Remove old environment variables
-
-```bash
-# Remove these from your environment
-# DISABLE_QUORUM_QUEUES_CONSUME
-# DISABLE_QUORUM_QUEUES_PUBLISH
-```
-
-**Step 4**: Update `assertExchange` calls
-
-```typescript
-// Before
-await rabbit.assertExchange(exchange, connectionData);
-
-// After
-await rabbit.assertExchange(exchange);
-```
-
-#### Gradual Migration Strategy
-
-For safe migration across multiple services:
-
-1. **Deploy with empty `QUORUM_QUEUES`** initially (all queues remain classic):
-   ```bash
-   QUORUM_QUEUES=""
-   ```
-
-2. **Gradually add queues** to the list:
-   ```bash
-   QUORUM_QUEUES="order-events"  # Start with one
-   # Monitor and verify
-   QUORUM_QUEUES="order-events,user-updates"  # Add more
-   ```
-
-3. **Remove old parameters** from code (cleanup):
-   ```typescript
-   // Remove isQuorumQueue parameters
-   await rabbit.sendToQueue(queue, data, options, headers);
-   ```
-
-#### Benefits of V6
-
-- **40% less code**: Removed ~600 lines of duplicate infrastructure
-- **Better maintainability**: Single code path for all queue types
-- **Clearer configuration**: Queue type determined by name, not global flags
-- **Improved performance**: Connection pooling reduces memory overhead
-- **Easier testing**: Simpler architecture with fewer edge cases
-
-### V5 Migration
-
-The breaking change in version 5 is the removal of `zehut` from dependencies and usage as a peer-dependency.
+The breaking change in this version is the removal of `zehut` from dependencies and usage as a peer-dependency.
 The required version of zehut is now `^4.0.0`.
 
 This was moved to being a peer-dependency in order to ensure that the version of `zehut` used here is the same as used in the MS, and not risk the package using v4 while the service is using v3, which would cause `zehut` to have multiple traces, which will not all hold the correct data.
 
-Additionally, the minimum node version is now 18, due to the minimum version of node defined in `zehut`.
-
-## Examples
-
-### Basic Producer-Consumer
-
-```typescript
-import RabbitMq from '@autofleet/rabbit';
-
-const rabbit = new RabbitMq();
-
-// Set up quorum queues
-process.env.QUORUM_QUEUES = 'important-events';
-
-// Producer
-async function sendEvent(event: any) {
-  await rabbit.sendToQueue('important-events', event);
-}
-
-// Consumer
-async function startConsumer() {
-  await rabbit.consume('important-events', async (msg, ack, nack) => {
-    try {
-      console.log('Processing event:', msg.content);
-      await processEvent(msg.content);
-      await ack();
-    } catch (error) {
-      console.error('Failed to process event:', error);
-      await nack(msg); // Will retry based on options
-    }
-  }, {
-    retries: 3,
-    limit: 10,
-  });
-}
-
-startConsumer();
-```
-
-### Fan-out Pattern with Exchange
-
-```typescript
-import RabbitMq from '@autofleet/rabbit';
-
-const rabbit = new RabbitMq();
-
-// Set up exchange and queues
-await rabbit.assertExchange('notifications');
-await rabbit.assertQueue('email-notifications');
-await rabbit.assertQueue('sms-notifications');
-await rabbit.bindQueue('email-notifications', 'notifications');
-await rabbit.bindQueue('sms-notifications', 'notifications');
-
-// Publisher
-await rabbit.publish('notifications', {
-  type: 'order.created',
-  orderId: 123,
-});
-
-// Email consumer
-await rabbit.consumeFromExchange('email-notifications', 'notifications',
-  async (msg, ack, nack) => {
-    await sendEmail(msg.content);
-    await ack();
-  }
-);
-
-// SMS consumer
-await rabbit.consumeFromExchange('sms-notifications', 'notifications',
-  async (msg, ack, nack) => {
-    await sendSMS(msg.content);
-    await ack();
-  }
-);
-```
-
-### With Redis Locking
-
-```typescript
-import RabbitMq from '@autofleet/rabbit';
-
-const rabbit = new RabbitMq(undefined, {
-  host: 'localhost',
-  port: 6379,
-  prefix: 'myapp:',
-});
-
-await rabbit.consume('order-processing', async (msg, ack, nack) => {
-  // Redis lock is automatically acquired before this callback
-  // and released after ack/nack
-
-  await processOrder(msg.content);
-  await ack(); // Lock is released here
-}, {
-  useConsumeWithLock: true,
-  lockTimeout: 30000, // 30 seconds
-});
-```
-
-## License
-
-ISC
-
-## Contributing
-
-Please report issues at: https://github.com/autofleet/autorepo
+Additionally, the minimum node version is now 18, due to the minimum version of node defined in `zehut`.

package/dist/{index-CBlhQYQ_.d.cts → index-DG_7Rl-n.d.ts}

@@ -1,9 +1,10 @@
+import { EventEmitter } from "node:events";
 import RedisLock from "redis-lock";
 import { AmqpConnectionManager, ChannelWrapper, CreateChannelOpts } from "amqp-connection-manager";
-import { PublishOptions } from "amqp-connection-manager/dist/types/ChannelWrapper";
-import { ConfirmChannel, ConsumeMessage, Options, Replies } from "amqplib";
 import { LoggerInstanceManager } from "@autofleet/logger";
 import { createClient } from "redis";
+import { PublishOptions } from "amqp-connection-manager/dist/types/ChannelWrapper";
+import { ConfirmChannel, ConsumeMessage, Options, Replies } from "amqplib";
 
 //#region src/lib/redis.d.ts
 interface RedisConfig {
@@ -14,6 +15,10 @@ interface RedisConfig {
 declare const getRedisInstance: (config: RedisConfig) => ReturnType<typeof createClient>;
 //#endregion
 //#region src/lib/types.d.ts
+type ExchangesCache = Record<string, Replies.AssertExchange | undefined>;
+type QueuesCache = Record<string, Replies.AssertQueue | undefined>;
+type QueueSetupPromisesDictionary = Record<string, Promise<Replies.AssertQueue> | undefined>;
+type AssertExchangePromisesDictionary = Record<string, Promise<Replies.AssertExchange> | undefined>;
 interface CustomMessageHeaders {
   redisTimestampValidationKey?: string;
 }
@@ -27,6 +32,7 @@ interface ConsumeOptions {
   useConsumeWithLock?: boolean;
   auditContext?: any;
   enableRabbitTrace?: boolean;
+  isQuorumQueue?: boolean;
 }
 interface NackOptions {
   skipRetry?: boolean;
@@ -34,7 +40,7 @@ interface NackOptions {
 type Message = Omit<ConsumeMessage, "content"> & {
   content: any;
 };
-type CallbackFunction = (msg: Message, ack: () => Promise<void>, nack: (ignored: ConsumeMessageOrNull, nackOptions?: NackOptions) => Promise<void>) => Promise<void>;
+type CallbackFunction = (msg: Message, ack: () => Promise<void>, nack: (ignored: ConsumeMessageOrNull, nackOptions?: NackOptions) => Promise<void>, signal?: AbortSignal) => Promise<void>;
 interface ConnectionData {
   amqpConnection: AmqpConnectionManager | null;
   creatingConnection: boolean;
@@ -58,7 +64,8 @@ declare function sendCeleryTaskViaHttp(data: TaskData, {
 interface IAfRabbitMq {
   ack(channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: (() => Promise<void>) | null): (userMsg: ConsumeMessage) => Promise<void>;
   nack(channel: ConfirmChannel, queue: string, options: ConsumeOptions, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock?: () => Promise<void>): (userMsg: ConsumeMessageOrNull, nackOptions?: NackOptions) => Promise<void>;
-  assertExchange(exchangeName: string, vhost?: string): Promise<Replies.AssertExchange>;
+  assertChannel(options?: assertChannelOpts): Promise<ChannelWrapper>;
+  assertExchange(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
   assertQueue(queueName: string, options?: Options.AssertQueue | null): Promise<Replies.AssertQueue>;
   consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
   consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
@@ -88,6 +95,11 @@ interface newChannelOpts {
   options?: CreateChannelOpts | undefined;
   connection: ConnectionData;
 }
+interface assertChannelOpts {
+  channelName?: string;
+  force?: boolean;
+  connection: ConnectionData;
+}
 declare class RabbitMq implements IAfRabbitMq {
   #private;
   readonly options: AfRabbitOptions;
@@ -97,61 +109,100 @@ declare class RabbitMq implements IAfRabbitMq {
   static getPublishOptions(customHeaders?: CustomMessageHeaders): PublishOptions;
   readonly DISCONNECT_MSG = "rabbit: connection disconnect";
   readonly RECONNECT_MSG = "rabbit: connection disconnect - reconnecting";
+  publishChannel: ChannelWrapper | null;
+  publishChannelSetupPromise: Promise<ChannelWrapper> | null;
+  readonly publishConnection: ConnectionData;
+  readonly consumeConnection: ConnectionData;
+  readonly em: EventEmitter;
+  readonly exchanges: ExchangesCache;
+  readonly queues: QueuesCache;
+  readonly queueSetupPromises: QueueSetupPromisesDictionary;
+  readonly assertExchangePromises: AssertExchangePromisesDictionary;
   readonly redisClient?: ReturnType<typeof getRedisInstance>;
   readonly redisLock?: ReturnType<typeof RedisLock>;
-  private readonly em;
+  /** A map of consumers' tags used for canceling consumption */
+  readonly consumersTags: Map<string, {
+    channel: ConfirmChannel;
+    consumerTag: string;
+  }>;
+  private readonly consumersToRegister;
   private doesVHostExist;
   private readonly vhost;
   private gracefulShutdownStarted;
-  private readonly quorumQueues;
-  private readonly publishConnections;
-  private readonly consumeConnections;
-  private readonly publishChannels;
-  private readonly publishChannelSetupPromises;
-  private readonly queuesByVhost;
-  private readonly exchangesByVhost;
-  private readonly queueSetupPromisesByVhost;
-  private readonly assertExchangePromisesByVhost;
-  private readonly consumersTagsByVhost;
-  private readonly consumersToRegisterByVhost;
+  shutdownAbortController: AbortController;
+  oldPublishChannel: ChannelWrapper | null;
+  oldPublishChannelSetupPromise: Promise<ChannelWrapper> | null;
+  readonly oldPublishConnection: ConnectionData;
+  readonly oldConsumeConnection: ConnectionData;
+  readonly oldEm: EventEmitter;
+  readonly oldExchanges: ExchangesCache;
+  readonly oldQueues: QueuesCache;
+  readonly oldQueueSetupPromises: QueueSetupPromisesDictionary;
+  readonly oldAssertExchangePromises: AssertExchangePromisesDictionary;
+  readonly oldConsumersTags: Map<string, {
+    channel: ConfirmChannel;
+    consumerTag: string;
+  }>;
+  private readonly oldConsumersToRegister;
   constructor(options?: AfRabbitOptions, redisConfig?: RedisConfig | undefined);
   private getRedisKey;
-  private isQuorumQueue;
-  private getVhostForQueue;
   private assertVHost;
   private shouldConsumeMessageByTimestamp;
   ack: (channel: ConfirmChannel, msg: ConsumeMessageOrNull, shouldUpdateRedisTimestamp?: boolean, releaseLock?: (() => Promise<void>) | null) => (userMsg: ConsumeMessage) => Promise<void>;
   nack: (channel: ConfirmChannel, queue: string, options: ConsumeOptions, deadQueueOptions: Options.AssertQueue, msg: ConsumeMessageOrNull, releaseLock?: (() => Promise<void>) | null) => (userMsg: ConsumeMessageOrNull, {
     skipRetry
   }?: NackOptions) => Promise<void>;
-  getConnection(connection: ConnectionData, vhost?: string): Promise<AmqpConnectionManager>;
-  getConnectionForVhost(vhost: string, type: "publish" | "consume"): Promise<AmqpConnectionManager>;
-  getConnectionDataForVhost(vhost: string, type: "publish" | "consume"): ConnectionData;
-  assertChannelForVhost(vhost: string, force?: boolean): Promise<ChannelWrapper>;
+  getConnection(connection: ConnectionData): Promise<AmqpConnectionManager>;
   getNewChannel({
     name,
     onClose,
     options,
     connection
   }: newChannelOpts): Promise<ChannelWrapper>;
-  assertExchange(exchangeName: string, vhost?: string): Promise<Replies.AssertExchange>;
+  assertChannel({
+    force,
+    connection
+  }: assertChannelOpts): Promise<ChannelWrapper>;
+  assertExchange(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
   getQueueLength(queue: string): Promise<Replies.AssertQueue>;
   private deleteQueue;
   bindQueue(queue: string, exchange: string): Promise<void>;
-  setupQueue(queueName: string, options?: Options.AssertQueue, vhost?: string): Promise<Replies.AssertQueue>;
+  setupQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+  static shouldUseQuorum(queueName: string): boolean;
   assertQueue(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
   private saveConsumer;
   consume(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
+  consumeNew(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
+  consumeOld(queue: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
   private lockRedisIfNeeded;
   private unlockRedisIfNeeded;
   private consumeFromRabbit;
   consumeFromExchange(queue: string, exchange: string, callback: CallbackFunction, options?: ConsumeOptions): Promise<void>;
-  publish(exchange: string, content: any, customHeaders?: PublishOptions["headers"], _isQuorumQueue?: boolean): Promise<void>;
-  sendToQueue(queue: string, content: any, options?: Options.AssertQueue, customHeaders?: PublishOptions["headers"], _isQuorumQueue?: boolean): Promise<boolean | undefined>;
+  publish(exchange: string, content: any, customHeaders?: PublishOptions["headers"], isQuorumQueue?: boolean): Promise<void>;
+  sendToQueue(queue: string, content: any, options?: Options.AssertQueue, customHeaders?: PublishOptions["headers"], isQuorumQueue?: boolean): Promise<boolean | undefined>;
   isConnected(): Promise<boolean>;
   gracefulShutdown(signal: string): Promise<void>;
+  private consumeFromRabbitOld;
+  getNewChannelOld({
+    name,
+    onClose,
+    options,
+    connection
+  }: newChannelOpts): Promise<ChannelWrapper>;
+  getConnectionOld(connection: ConnectionData): Promise<AmqpConnectionManager>;
+  private saveConsumerOld;
+  assertQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+  setupQueueOld(queueName: string, options?: Options.AssertQueue): Promise<Replies.AssertQueue>;
+  assertChannelOld({
+    force,
+    connection
+  }: assertChannelOpts): Promise<ChannelWrapper>;
+  private deleteQueueOld;
+  assertExchangeOld(exchangeName: string, connection: ConnectionData): Promise<Replies.AssertExchange>;
+  isConnectedOld(): Promise<boolean>;
   private maskURL;
 }
+type ConsumerCallbackFunction = CallbackFunction;
 //#endregion
-export { sendCeleryTaskViaHttp as i, IAfRabbitMq as n, RabbitMq as r, AfRabbitOptions as t };
-//# sourceMappingURL=index-CBlhQYQ_.d.cts.map
+export { sendCeleryTaskViaHttp as a, RabbitMq as i, ConsumerCallbackFunction as n, IAfRabbitMq as r, AfRabbitOptions as t };
+//# sourceMappingURL=index-DG_7Rl-n.d.ts.map