TRaw is the provider’s native raw
payload (proto.IWebMessageInfo, webhook entry, gateway object); it stays
unknown in all shared code and is narrowed only inside provider-specific
paths.
STABILITY CONTRACT (normative): for the lifetime of a session, the same
entity MUST yield the same senderId and the same chat the same chatId on
every emitted event. All transport-internal aliasing is resolved inside the
provider before emission. The core performs no identity reconciliation.
INBOUND ID CONTRACT (normative): a message’s ref.id and an interaction’s
interactionId identify ONE logical inbound event within its chat: distinct
events get distinct ids, and a redelivery of the same event (webhook retry,
reconnect replay) carries the same id. Core relies on this for inbound
idempotency (BotConfig.dedupe, keyed by chatId + id). When the transport
provides no such id, synthesize one from per-event data that a redelivery
repeats (e.g. kind + event timestamp) or emit '', which opts the event out
of deduplication. Never fall back to a per-user constant (sender id,
user_ref) or a shared placeholder ('<prefix>_0').
Type Parameters
Properties
id
capabilities
selfId?
connection?
Methods
start()
Returns
Promise<void>
stop()
Returns
Promise<void>
send()
Parameters
Returns
Promise<SendResult<TRaw>>
onEvent()
Parameters
Returns
() =>void
ingest()?
Parameters
Returns
unknown
downloadMedia()?
Parameters
Returns
Promise<Buffer<ArrayBufferLike> | ReadableStream>
serializeMediaRef()?
BotConfig.durability): turn a live MediaRef into a JSON-safe,
versioned reference that rehydrateMediaRef can rebuild in another process, so a
replayed message (crash recovery, background retry) can still download its media.
Synchronous, cheap and side-effect free; a throw counts as “not durable”. Return
undefined for a ref that must not be journaled (e.g. view-once media). Never include
credentials: the result is stored at rest with the inbound record.
Parameters
Returns
SerializedMediaRef | undefined
rehydrateMediaRef()?
MediaRef of a replayed message from what serializeMediaRef wrote.
ref is the journaled ref without its token. Pure decoding: it must not need the
transport to be connected. stored comes from storage and is UNTRUSTED: reject an
invalid, unknown-version or tampered value with a ProviderError.
Parameters
Returns
MediaRef | Promise<MediaRef>
getMessage()?
getMessage callback baked into BaileysProvider today.
Parameters
Returns
Promise<InboundMessage<TRaw> | undefined>
markRead()?
Parameters
Returns
Promise<void>
typing()?
Parameters
Returns
Promise<void>
deleteMessage()?
Parameters
Returns
Promise<void>
editMessage()?
Parameters
Returns
Promise<SendResult<TRaw>>
acknowledgeInteraction()?
Parameters
Returns
Promise<void>
sendDraft()?
draftId → the same draft is updated in place. A draft is
NOT a message: the caller must still send() the final text. Only for
providers with capabilities.streaming === 'draft'; rejects (typed error)
where the transport refuses drafts (e.g. Telegram groups), and the caller
then falls back to edits or chunks.
Parameters
Returns
Promise<void>
canRenderForm()?
form OutboundContent for form (and opts.nativeId) can be
rendered natively right now, e.g. whether a WhatsApp Flow is mapped to it.
Only consulted when capabilities.forms === 'native'; when it returns
false, an auto-mode flow().form() asks field by field without sending
(and failing) a form message first. Absent = every form is renderable.
Parameters
Returns
boolean
textFormatFor()?
whatsapp: chats
render WhatsApp markup, SMS chats render none). Return undefined when the
chat’s format is unknown; the core then falls back to
capabilities.textFormat. Exposed as ctx.textFormat. Must be synchronous
and cheap (it runs once per inbound message). Absent = every chat uses
capabilities.textFormat.
Parameters
Returns
TextFormat | undefined