@rocketmq/amqp 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,21 @@
+
+
+> @rocketmq/amqp@0.1.0 build /home/edilson/learnspace/rocketmq-broker/client-ts/packages/amqp
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/edilson/learnspace/rocketmq-broker/client-ts/packages/amqp/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+ESM dist/index.js 1.64 KB
+ESM ⚡️ Build success in 13ms
+CJS dist/index.cjs 3.31 KB
+CJS ⚡️ Build success in 13ms
+DTS Build start
+DTS ⚡️ Build success in 965ms
+DTS dist/index.d.ts  2.74 KB
+DTS dist/index.d.cts 2.74 KB

package/dist/index.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AmqpChannel: () => AmqpChannel,
+  AmqpConnection: () => AmqpConnection
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/connection.ts
+var import_amqplib = __toESM(require("amqplib"), 1);
+
+// src/channel.ts
+var AmqpChannel = class {
+  constructor(ch) {
+    this.ch = ch;
+  }
+  ch;
+  /** Exposes the raw amqplib channel for event listeners (e.g. "error"). */
+  get raw() {
+    return this.ch;
+  }
+  async assertQueue(name, opts) {
+    return this.ch.assertQueue(name, opts);
+  }
+  async assertExchange(name, type, opts) {
+    return this.ch.assertExchange(name, type, opts);
+  }
+  async bindQueue(queue, exchange, routingKey) {
+    return this.ch.bindQueue(queue, exchange, routingKey);
+  }
+  sendToQueue(queue, content, opts) {
+    return this.ch.sendToQueue(queue, content, opts);
+  }
+  publish(exchange, routingKey, content, opts) {
+    return this.ch.publish(exchange, routingKey, content, opts);
+  }
+  async consume(queue, handler, opts) {
+    return this.ch.consume(queue, handler, opts);
+  }
+  ack(msg) {
+    this.ch.ack(msg);
+  }
+  nack(msg, requeue) {
+    this.ch.nack(msg, false, requeue);
+  }
+  async prefetch(count) {
+    await this.ch.prefetch(count);
+  }
+  async close() {
+    await this.ch.close();
+  }
+};
+
+// src/connection.ts
+var AmqpConnection = class _AmqpConnection {
+  constructor(conn) {
+    this.conn = conn;
+  }
+  conn;
+  /** Opens a new AMQP connection to the given URL. */
+  static async connect(url) {
+    const conn = await import_amqplib.default.connect(url);
+    return new _AmqpConnection(conn);
+  }
+  /** Creates a new channel on this connection. */
+  async createChannel() {
+    const ch = await this.conn.createChannel();
+    return new AmqpChannel(ch);
+  }
+  /** Closes the underlying TCP connection. */
+  async close() {
+    await this.conn.close();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AmqpChannel,
+  AmqpConnection
+});

package/dist/index.d.cts

@@ -0,0 +1,70 @@
+import amqp from 'amqplib';
+
+/**
+ * Re-exported amqplib types used across the SDK.
+ *
+ * Centralizes the amqplib dependency so other packages never
+ * import from amqplib directly.
+ */
+
+type ConsumeMessage = amqp.ConsumeMessage;
+type PublishOptions = amqp.Options.Publish;
+type ConsumeOptions = amqp.Options.Consume;
+type AssertQueueOptions = amqp.Options.AssertQueue;
+type AssertExchangeOptions = amqp.Options.AssertExchange;
+type AssertQueueReply = amqp.Replies.AssertQueue;
+type AssertExchangeReply = amqp.Replies.AssertExchange;
+type ConsumeReply = amqp.Replies.Consume;
+type EmptyReply = amqp.Replies.Empty;
+
+/**
+ * Thin wrapper around an amqplib Channel.
+ *
+ * Exposes only the operations the SDK needs without leaking the full
+ * amqplib surface. No schema or validation logic lives here.
+ *
+ * Usage:
+ *   const ch = await connection.createChannel();
+ *   ch.sendToQueue("orders", buffer, { persistent: true });
+ */
+
+declare class AmqpChannel {
+    private readonly ch;
+    constructor(ch: amqp.Channel);
+    /** Exposes the raw amqplib channel for event listeners (e.g. "error"). */
+    get raw(): amqp.Channel;
+    assertQueue(name: string, opts?: AssertQueueOptions): Promise<AssertQueueReply>;
+    assertExchange(name: string, type: string, opts?: AssertExchangeOptions): Promise<AssertExchangeReply>;
+    bindQueue(queue: string, exchange: string, routingKey: string): Promise<EmptyReply>;
+    sendToQueue(queue: string, content: Buffer, opts?: PublishOptions): boolean;
+    publish(exchange: string, routingKey: string, content: Buffer, opts?: PublishOptions): boolean;
+    consume(queue: string, handler: (msg: ConsumeMessage | null) => void, opts?: ConsumeOptions): Promise<ConsumeReply>;
+    ack(msg: ConsumeMessage): void;
+    nack(msg: ConsumeMessage, requeue?: boolean): void;
+    prefetch(count: number): Promise<void>;
+    close(): Promise<void>;
+}
+
+/**
+ * Manages the AMQP connection lifecycle.
+ *
+ * Wraps amqplib's connect() and exposes a single createChannel() method.
+ * No schema, validation, or serialization logic lives here.
+ *
+ * Usage:
+ *   const conn = await AmqpConnection.connect("amqp://localhost");
+ *   const ch = await conn.createChannel();
+ */
+
+declare class AmqpConnection {
+    private readonly conn;
+    private constructor();
+    /** Opens a new AMQP connection to the given URL. */
+    static connect(url: string): Promise<AmqpConnection>;
+    /** Creates a new channel on this connection. */
+    createChannel(): Promise<AmqpChannel>;
+    /** Closes the underlying TCP connection. */
+    close(): Promise<void>;
+}
+
+export { AmqpChannel, AmqpConnection, type AssertExchangeOptions, type AssertExchangeReply, type AssertQueueOptions, type AssertQueueReply, type ConsumeMessage, type ConsumeOptions, type ConsumeReply, type EmptyReply, type PublishOptions };

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+import amqp from 'amqplib';
+
+/**
+ * Re-exported amqplib types used across the SDK.
+ *
+ * Centralizes the amqplib dependency so other packages never
+ * import from amqplib directly.
+ */
+
+type ConsumeMessage = amqp.ConsumeMessage;
+type PublishOptions = amqp.Options.Publish;
+type ConsumeOptions = amqp.Options.Consume;
+type AssertQueueOptions = amqp.Options.AssertQueue;
+type AssertExchangeOptions = amqp.Options.AssertExchange;
+type AssertQueueReply = amqp.Replies.AssertQueue;
+type AssertExchangeReply = amqp.Replies.AssertExchange;
+type ConsumeReply = amqp.Replies.Consume;
+type EmptyReply = amqp.Replies.Empty;
+
+/**
+ * Thin wrapper around an amqplib Channel.
+ *
+ * Exposes only the operations the SDK needs without leaking the full
+ * amqplib surface. No schema or validation logic lives here.
+ *
+ * Usage:
+ *   const ch = await connection.createChannel();
+ *   ch.sendToQueue("orders", buffer, { persistent: true });
+ */
+
+declare class AmqpChannel {
+    private readonly ch;
+    constructor(ch: amqp.Channel);
+    /** Exposes the raw amqplib channel for event listeners (e.g. "error"). */
+    get raw(): amqp.Channel;
+    assertQueue(name: string, opts?: AssertQueueOptions): Promise<AssertQueueReply>;
+    assertExchange(name: string, type: string, opts?: AssertExchangeOptions): Promise<AssertExchangeReply>;
+    bindQueue(queue: string, exchange: string, routingKey: string): Promise<EmptyReply>;
+    sendToQueue(queue: string, content: Buffer, opts?: PublishOptions): boolean;
+    publish(exchange: string, routingKey: string, content: Buffer, opts?: PublishOptions): boolean;
+    consume(queue: string, handler: (msg: ConsumeMessage | null) => void, opts?: ConsumeOptions): Promise<ConsumeReply>;
+    ack(msg: ConsumeMessage): void;
+    nack(msg: ConsumeMessage, requeue?: boolean): void;
+    prefetch(count: number): Promise<void>;
+    close(): Promise<void>;
+}
+
+/**
+ * Manages the AMQP connection lifecycle.
+ *
+ * Wraps amqplib's connect() and exposes a single createChannel() method.
+ * No schema, validation, or serialization logic lives here.
+ *
+ * Usage:
+ *   const conn = await AmqpConnection.connect("amqp://localhost");
+ *   const ch = await conn.createChannel();
+ */
+
+declare class AmqpConnection {
+    private readonly conn;
+    private constructor();
+    /** Opens a new AMQP connection to the given URL. */
+    static connect(url: string): Promise<AmqpConnection>;
+    /** Creates a new channel on this connection. */
+    createChannel(): Promise<AmqpChannel>;
+    /** Closes the underlying TCP connection. */
+    close(): Promise<void>;
+}
+
+export { AmqpChannel, AmqpConnection, type AssertExchangeOptions, type AssertExchangeReply, type AssertQueueOptions, type AssertQueueReply, type ConsumeMessage, type ConsumeOptions, type ConsumeReply, type EmptyReply, type PublishOptions };

package/dist/index.js

@@ -0,0 +1,70 @@
+// src/connection.ts
+import amqp from "amqplib";
+
+// src/channel.ts
+var AmqpChannel = class {
+  constructor(ch) {
+    this.ch = ch;
+  }
+  ch;
+  /** Exposes the raw amqplib channel for event listeners (e.g. "error"). */
+  get raw() {
+    return this.ch;
+  }
+  async assertQueue(name, opts) {
+    return this.ch.assertQueue(name, opts);
+  }
+  async assertExchange(name, type, opts) {
+    return this.ch.assertExchange(name, type, opts);
+  }
+  async bindQueue(queue, exchange, routingKey) {
+    return this.ch.bindQueue(queue, exchange, routingKey);
+  }
+  sendToQueue(queue, content, opts) {
+    return this.ch.sendToQueue(queue, content, opts);
+  }
+  publish(exchange, routingKey, content, opts) {
+    return this.ch.publish(exchange, routingKey, content, opts);
+  }
+  async consume(queue, handler, opts) {
+    return this.ch.consume(queue, handler, opts);
+  }
+  ack(msg) {
+    this.ch.ack(msg);
+  }
+  nack(msg, requeue) {
+    this.ch.nack(msg, false, requeue);
+  }
+  async prefetch(count) {
+    await this.ch.prefetch(count);
+  }
+  async close() {
+    await this.ch.close();
+  }
+};
+
+// src/connection.ts
+var AmqpConnection = class _AmqpConnection {
+  constructor(conn) {
+    this.conn = conn;
+  }
+  conn;
+  /** Opens a new AMQP connection to the given URL. */
+  static async connect(url) {
+    const conn = await amqp.connect(url);
+    return new _AmqpConnection(conn);
+  }
+  /** Creates a new channel on this connection. */
+  async createChannel() {
+    const ch = await this.conn.createChannel();
+    return new AmqpChannel(ch);
+  }
+  /** Closes the underlying TCP connection. */
+  async close() {
+    await this.conn.close();
+  }
+};
+export {
+  AmqpChannel,
+  AmqpConnection
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@rocketmq/amqp",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "amqplib": "^0.10.5"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.10.6"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run"
+  }
+}

package/src/channel.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tests for AmqpChannel — thin wrapper over amqplib Channel.
+ *
+ * Uses a FakeChannel mock class to avoid real AMQP connections.
+ * Covers every method: assertQueue, assertExchange, bindQueue,
+ * sendToQueue, publish, consume, ack, nack, prefetch, close.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { AmqpChannel } from './channel.js';
+
+/** Named fake class per user rules — no inline stubs. */
+class FakeChannel {
+  assertQueue = vi.fn().mockResolvedValue({ queue: 'q', messageCount: 0, consumerCount: 0 });
+  assertExchange = vi.fn().mockResolvedValue({ exchange: 'ex' });
+  bindQueue = vi.fn().mockResolvedValue({});
+  sendToQueue = vi.fn().mockReturnValue(true);
+  publish = vi.fn().mockReturnValue(true);
+  consume = vi.fn().mockResolvedValue({ consumerTag: 'tag-1' });
+  ack = vi.fn();
+  nack = vi.fn();
+  prefetch = vi.fn().mockResolvedValue(undefined);
+  close = vi.fn().mockResolvedValue(undefined);
+}
+
+describe('AmqpChannel', () => {
+  let fake: FakeChannel;
+  let channel: AmqpChannel;
+
+  beforeEach(() => {
+    fake = new FakeChannel();
+    // Cast to satisfy amqp.Channel type — only the methods we call exist
+    channel = new AmqpChannel(fake as never);
+  });
+
+  it('exposes raw channel via .raw', () => {
+    expect(channel.raw).toBe(fake);
+  });
+
+  it('delegates assertQueue', async () => {
+    const result = await channel.assertQueue('orders', { durable: true });
+    expect(fake.assertQueue).toHaveBeenCalledWith('orders', { durable: true });
+    expect(result.queue).toBe('q');
+  });
+
+  it('delegates assertExchange', async () => {
+    const result = await channel.assertExchange('ex', 'direct', { durable: true });
+    expect(fake.assertExchange).toHaveBeenCalledWith('ex', 'direct', { durable: true });
+    expect(result.exchange).toBe('ex');
+  });
+
+  it('delegates bindQueue', async () => {
+    await channel.bindQueue('q', 'ex', 'key');
+    expect(fake.bindQueue).toHaveBeenCalledWith('q', 'ex', 'key');
+  });
+
+  it('delegates sendToQueue', () => {
+    const buf = Buffer.from('test');
+    const result = channel.sendToQueue('q', buf, { persistent: true });
+    expect(fake.sendToQueue).toHaveBeenCalledWith('q', buf, { persistent: true });
+    expect(result).toBe(true);
+  });
+
+  it('delegates publish', () => {
+    const buf = Buffer.from('test');
+    const result = channel.publish('ex', 'key', buf, { persistent: true });
+    expect(fake.publish).toHaveBeenCalledWith('ex', 'key', buf, { persistent: true });
+    expect(result).toBe(true);
+  });
+
+  it('delegates consume', async () => {
+    const handler = vi.fn();
+    const result = await channel.consume('q', handler, { noAck: false });
+    expect(fake.consume).toHaveBeenCalledWith('q', handler, { noAck: false });
+    expect(result.consumerTag).toBe('tag-1');
+  });
+
+  it('delegates ack', () => {
+    const msg = { fields: {}, properties: {}, content: Buffer.from('') } as never;
+    channel.ack(msg);
+    expect(fake.ack).toHaveBeenCalledWith(msg);
+  });
+
+  it('delegates nack with requeue', () => {
+    const msg = { fields: {}, properties: {}, content: Buffer.from('') } as never;
+    channel.nack(msg, true);
+    expect(fake.nack).toHaveBeenCalledWith(msg, false, true);
+  });
+
+  it('delegates nack without requeue', () => {
+    const msg = { fields: {}, properties: {}, content: Buffer.from('') } as never;
+    channel.nack(msg);
+    expect(fake.nack).toHaveBeenCalledWith(msg, false, undefined);
+  });
+
+  it('delegates prefetch', async () => {
+    await channel.prefetch(10);
+    expect(fake.prefetch).toHaveBeenCalledWith(10);
+  });
+
+  it('delegates close', async () => {
+    await channel.close();
+    expect(fake.close).toHaveBeenCalled();
+  });
+});

package/src/channel.ts

@@ -0,0 +1,80 @@
+/**
+ * Thin wrapper around an amqplib Channel.
+ *
+ * Exposes only the operations the SDK needs without leaking the full
+ * amqplib surface. No schema or validation logic lives here.
+ *
+ * Usage:
+ *   const ch = await connection.createChannel();
+ *   ch.sendToQueue("orders", buffer, { persistent: true });
+ */
+
+import type amqp from 'amqplib';
+import type {
+  AssertQueueOptions,
+  AssertQueueReply,
+  AssertExchangeOptions,
+  AssertExchangeReply,
+  ConsumeMessage,
+  ConsumeOptions,
+  ConsumeReply,
+  EmptyReply,
+  PublishOptions,
+} from './types.js';
+
+export class AmqpChannel {
+  constructor(private readonly ch: amqp.Channel) {}
+
+  /** Exposes the raw amqplib channel for event listeners (e.g. "error"). */
+  get raw(): amqp.Channel {
+    return this.ch;
+  }
+
+  async assertQueue(name: string, opts?: AssertQueueOptions): Promise<AssertQueueReply> {
+    return this.ch.assertQueue(name, opts);
+  }
+
+  async assertExchange(
+    name: string,
+    type: string,
+    opts?: AssertExchangeOptions,
+  ): Promise<AssertExchangeReply> {
+    return this.ch.assertExchange(name, type, opts);
+  }
+
+  async bindQueue(queue: string, exchange: string, routingKey: string): Promise<EmptyReply> {
+    return this.ch.bindQueue(queue, exchange, routingKey);
+  }
+
+  sendToQueue(queue: string, content: Buffer, opts?: PublishOptions): boolean {
+    return this.ch.sendToQueue(queue, content, opts);
+  }
+
+  publish(exchange: string, routingKey: string, content: Buffer, opts?: PublishOptions): boolean {
+    return this.ch.publish(exchange, routingKey, content, opts);
+  }
+
+  async consume(
+    queue: string,
+    handler: (msg: ConsumeMessage | null) => void,
+    opts?: ConsumeOptions,
+  ): Promise<ConsumeReply> {
+    return this.ch.consume(queue, handler, opts);
+  }
+
+  ack(msg: ConsumeMessage): void {
+    this.ch.ack(msg);
+  }
+
+  nack(msg: ConsumeMessage, requeue?: boolean): void {
+    this.ch.nack(msg, false, requeue);
+  }
+
+  async prefetch(count: number): Promise<void> {
+    await this.ch.prefetch(count);
+  }
+
+  async close(): Promise<void> {
+    await this.ch.close();
+  }
+}

package/src/connection.test.ts

@@ -0,0 +1,54 @@
+/**
+ * Tests for AmqpConnection.
+ *
+ * Mocks the amqplib module to avoid real TCP connections.
+ * Covers connect, createChannel, and close.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { AmqpConnection } from './connection.js';
+
+// Mock amqplib at the module level
+vi.mock('amqplib', () => {
+  const fakeChannel = {
+    assertQueue: vi.fn().mockResolvedValue({ queue: 'q', messageCount: 0, consumerCount: 0 }),
+    close: vi.fn().mockResolvedValue(undefined),
+  };
+  const fakeConn = {
+    createChannel: vi.fn().mockResolvedValue(fakeChannel),
+    close: vi.fn().mockResolvedValue(undefined),
+  };
+  return {
+    default: {
+      connect: vi.fn().mockResolvedValue(fakeConn),
+    },
+  };
+});
+
+describe('AmqpConnection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('connects to the given URL', async () => {
+    const conn = await AmqpConnection.connect('amqp://localhost');
+    expect(conn).toBeInstanceOf(AmqpConnection);
+  });
+
+  it('creates an AmqpChannel from the connection', async () => {
+    const conn = await AmqpConnection.connect('amqp://localhost');
+    const ch = await conn.createChannel();
+    // AmqpChannel wraps the fake channel
+    expect(ch).toBeDefined();
+    expect(typeof ch.assertQueue).toBe('function');
+  });
+
+  it('closes the underlying connection', async () => {
+    const amqplib = await import('amqplib');
+    const conn = await AmqpConnection.connect('amqp://localhost');
+    await conn.close();
+    // Verify the mock connection's close was called
+    const mockConn = await amqplib.default.connect('amqp://localhost');
+    expect(mockConn.close).toHaveBeenCalled();
+  });
+});

package/src/connection.ts

@@ -0,0 +1,34 @@
+/**
+ * Manages the AMQP connection lifecycle.
+ *
+ * Wraps amqplib's connect() and exposes a single createChannel() method.
+ * No schema, validation, or serialization logic lives here.
+ *
+ * Usage:
+ *   const conn = await AmqpConnection.connect("amqp://localhost");
+ *   const ch = await conn.createChannel();
+ */
+
+import amqp from 'amqplib';
+import { AmqpChannel } from './channel.js';
+
+export class AmqpConnection {
+  private constructor(private readonly conn: amqp.ChannelModel) {}
+
+  /** Opens a new AMQP connection to the given URL. */
+  static async connect(url: string): Promise<AmqpConnection> {
+    const conn = await amqp.connect(url);
+    return new AmqpConnection(conn);
+  }
+
+  /** Creates a new channel on this connection. */
+  async createChannel(): Promise<AmqpChannel> {
+    const ch = await this.conn.createChannel();
+    return new AmqpChannel(ch);
+  }
+
+  /** Closes the underlying TCP connection. */
+  async close(): Promise<void> {
+    await this.conn.close();
+  }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export { AmqpConnection } from './connection.js';
+export { AmqpChannel } from './channel.js';
+export type {
+  ConsumeMessage,
+  PublishOptions,
+  ConsumeOptions,
+  AssertQueueOptions,
+  AssertExchangeOptions,
+  AssertQueueReply,
+  AssertExchangeReply,
+  ConsumeReply,
+  EmptyReply,
+} from './types.js';

package/src/types.ts

@@ -0,0 +1,18 @@
+/**
+ * Re-exported amqplib types used across the SDK.
+ *
+ * Centralizes the amqplib dependency so other packages never
+ * import from amqplib directly.
+ */
+
+import type amqp from 'amqplib';
+
+export type ConsumeMessage = amqp.ConsumeMessage;
+export type PublishOptions = amqp.Options.Publish;
+export type ConsumeOptions = amqp.Options.Consume;
+export type AssertQueueOptions = amqp.Options.AssertQueue;
+export type AssertExchangeOptions = amqp.Options.AssertExchange;
+export type AssertQueueReply = amqp.Replies.AssertQueue;
+export type AssertExchangeReply = amqp.Replies.AssertExchange;
+export type ConsumeReply = amqp.Replies.Consume;
+export type EmptyReply = amqp.Replies.Empty;

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  clean: true,
+});