Class AMQPQueue<P, C, KP, KC>

Readonlyname

bind

• bind(
      exchange: string | AMQPExchange<P, C, KP, KC>,
      routingKey?: string,
      args?: Record<string, unknown>,
  ): Promise<AMQPQueue<P, C, KP, KC>>

  Bind this queue to an exchange.

  Parameters

  • exchange: string | AMQPExchange<P, C, KP, KC>
  • routingKey: string = ""
  • args: Record<string, unknown> = {}

  Returns Promise<AMQPQueue<P, C, KP, KC>>

  this for chaining

consumeOne

• consumeOne(options?: { timeout?: number }): Promise<AMQPMessage<P>>

  Wait for a single message, then cancel the underlying consumer. Pairs with get (zero-wait poll) and subscribe (long-lived):

  • get() — is there a message right now? null otherwise.
  • consumeOne({ timeout }) — wait up to N ms for one message.
  • subscribe(cb) — keep delivering until cancelled.

  Throws when timeout elapses with no delivery — distinct from get()'s null return, so callers can't conflate "nothing" with "deadline missed".

  The library acks the delivered message before resolving and uses wire-level noAck: false with prefetch: 1 so the broker holds the queue at a single in-flight delivery; messages beyond the one returned stay in the queue for the next consumer.

  Parameters

  • options: { timeout?: number } = {}

    • Optionaltimeout?: number

      max wait in milliseconds (omit to wait forever)

  Returns Promise<AMQPMessage<P>>

delete

• delete(
      params?: { ifEmpty?: boolean; ifUnused?: boolean },
  ): Promise<MessageCount>

  Delete this queue.

  Parameters

  • Optionalparams: { ifEmpty?: boolean; ifUnused?: boolean }

    • OptionalifEmpty?: boolean

      only delete if the queue is empty

    • OptionalifUnused?: boolean

      only delete if the queue has no consumers

  Returns Promise<MessageCount>

get

• get(params?: { noAck?: boolean }): Promise<null | AMQPMessage<P>>

  Poll the queue for a single message.

  Parameters

  • Optionalparams: { noAck?: boolean }

    • OptionalnoAck?: boolean

      automatically acknowledge on delivery

  Returns Promise<null | AMQPMessage<P>>

publish

• publish<O extends string = KP>(
      body: ResolveBody<P, O>,
      options?: QueuePublishOptions<O>,
  ): Promise<AMQPQueue<P, C, KP, KC>>

  Publish a message directly to this queue (via the default exchange).

  When the session has parsers configured, body can be any value accepted by the matching parser's serialize method. Without parsers, body must be a string, Buffer, Uint8Array, or null.

  Defaults: confirm: true, deliveryMode: 2 (persistent). Pass deliveryMode: 1 to send a transient message.

  Type Parameters

  • O extends string = KP

  Parameters

  • body: ResolveBody<P, O>
  • options: QueuePublishOptions<O> = {}

    publish properties; set confirm: false to skip broker confirmation

  Returns Promise<AMQPQueue<P, C, KP, KC>>

  this for chaining

purge

• purge(): Promise<MessageCount>

  Purge all messages from this queue.

  Returns Promise<MessageCount>

subscribe

• subscribe(
      callback: (msg: AMQPMessage<P>) => void | Promise<void>,
  ): Promise<AMQPSubscription>

  Subscribe with a callback. Messages are acked after the callback returns, nacked on error.

  Parameters

  • callback: (msg: AMQPMessage<P>) => void | Promise<void>

  Returns Promise<AMQPSubscription>
• subscribe(
      params: QueueSubscribeParams,
      callback: (msg: AMQPMessage<P>) => void | Promise<void>,
  ): Promise<AMQPSubscription>

  Subscribe with a callback and custom params.

  Parameters

  • params: QueueSubscribeParams
  • callback: (msg: AMQPMessage<P>) => void | Promise<void>

  Returns Promise<AMQPSubscription>
• subscribe(params?: QueueSubscribeParams): Promise<AMQPGeneratorSubscription<P>>

  Subscribe via an async iterator. Messages continue yielding across reconnections.

  Parameters

  • Optionalparams: QueueSubscribeParams

  Returns Promise<AMQPGeneratorSubscription<P>>

  Example

  for await (const msg of await q.subscribe()) {
    console.log(msg.bodyString())
    await msg.ack()
  }
  Copy

unbind

• unbind(
      exchange: string | AMQPExchange<P, C, KP, KC>,
      routingKey?: string,
      args?: Record<string, unknown>,
  ): Promise<AMQPQueue<P, C, KP, KC>>

  Remove a binding between this queue and an exchange.

  Parameters

  • exchange: string | AMQPExchange<P, C, KP, KC>
  • routingKey: string = ""
  • args: Record<string, unknown> = {}

  Returns Promise<AMQPQueue<P, C, KP, KC>>

  this for chaining