@oxidezap/whatsapp-rust-bridge 0.6.0

package/dist/whatsapp_rust_bridge.d.ts

@@ -0,0 +1,3804 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * The `ReadableStreamType` enum.
+ *
+ * *This API requires the following crate features to be activated: `ReadableStreamType`*
+ */
+
+export type ReadableStreamType = "bytes";
+
+/**
+ * JS HTTP client callbacks. Implement using fetch() or any HTTP library.
+ */
+export interface JsHttpClientConfig {
+    execute(url: string, method: string, headers: Record<string, string>, body: Uint8Array | null): Promise<{ statusCode: number; body: Uint8Array }>;
+}
+
+
+
+/**
+ * JS transport callbacks for WebSocket management.
+ *
+ * Passed to `createWhatsAppClient` as the transport config.
+ *
+ * `connect(handle)` is called when the client needs a connection:
+ *   - Create a WebSocket
+ *   - Wire ws.onopen → handle.onConnected()
+ *   - Wire ws.onmessage → handle.onData(data)
+ *   - Wire ws.onclose → handle.onDisconnected()
+ *
+ * `send(data)` sends raw bytes over the active WebSocket.
+ * `sendBorrowed(data)`, when provided, is the zero-copy fast path. The view is
+ * borrowed from WASM memory and is valid ONLY for the synchronous duration of
+ * the call: implementations MUST consume/copy it before returning and MUST NOT
+ * retain it, re-enter WASM, or return a Promise. The mandatory `send` method is
+ * kept as the safe copying fallback for every other transport.
+ * `disconnect()` closes the WebSocket.
+ */
+export interface JsTransportHandle {
+    onConnected(): void;
+    onData(data: Uint8Array): void;
+    onDisconnected(): void;
+}
+
+/**
+ * Every Promise handed back to the bridge must settle, including on failure:
+ * reject rather than leaving it pending. The bridge awaits it through a
+ * wasm-bindgen `JsFuture`, whose resolve/reject pair is only released when the
+ * promise settles, so a promise that never settles retains two JS handles for
+ * the life of the process.
+ */
+export interface JsTransportCallbacks {
+    connect(handle: JsTransportHandle): void | Promise<void>;
+    send(data: Uint8Array): void | Promise<void>;
+    sendBorrowed?(data: Uint8Array): void;
+    disconnect(): void | Promise<void>;
+}
+
+
+
+/**
+ * Native crypto callbacks installed via `initWasmEngine` for large AES operations.
+ * Supply an implementation backed by the host platform's native crypto API.
+ */
+export interface JsCryptoCallbacks {
+    aesCbc256Encrypt(key: Uint8Array, iv: Uint8Array, plaintext: Uint8Array): Uint8Array;
+    aesCbc256Decrypt(key: Uint8Array, iv: Uint8Array, ciphertext: Uint8Array): Uint8Array;
+    aesGcm256Encrypt(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, plaintext: Uint8Array): Uint8Array;
+    aesGcm256Decrypt(key: Uint8Array, nonce: Uint8Array, aad: Uint8Array, ciphertextWithTag: Uint8Array): Uint8Array;
+    hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array;
+    hmacSha256TwoPart?(key: Uint8Array, first: Uint8Array, second: Uint8Array): Uint8Array;
+}
+
+
+
+/** Neutral binary stanza representation accepted by the client boundary. */
+export interface BinaryNode {
+    tag: string;
+    attrs: Record<string, string>;
+    content?: BinaryNode[] | string | Uint8Array;
+}
+
+
+
+/** WhatsApp JID (Jabber ID) — identifies a user, group, or device. */
+export interface Jid {
+    user: string;
+    server: string;
+    agent: number;
+    device: number;
+    integrator: number;
+}
+
+/** Addressing mode for a group (phone number vs LID). */
+export type AddressingMode = "pn" | "lid";
+
+/** A batched app-state sync finished without leaving every collection synced.  Collections are named as they appear on the wire (`critical_block`, `regular_high`, …) rather than as an enum, so the payload stays stable if the set of collections changes.  `fatal` is the one a consumer usually has to act on: the server refused the collection, and repeating the request gets the same answer. WhatsApp Web treats that as grounds to notify the primary device and log out; this library will not end a session on its own, so it reports the refusal and keeps the connection. When `connected` is true the client dispatched [`Event::Connected`] anyway and is usable, minus whatever those collections carry — for `critical_block` that includes the push name, so presence stays unavailable until it syncs. */
+export interface AppStateSyncFailed {
+    /** Refused outright by the server (400/404). Terminal for this connection. */
+    fatal: string[];
+    /** Did not sync, but a later attempt can. */
+    retryable: string[];
+    /** Another writer held the collection, so this sync did nothing for it. */
+    skipped: string[];
+    /** Whether the client went on to dispatch [`Event::Connected`]. */
+    connected: boolean;
+}
+
+/** App state synchronization key for WhatsApp's app state protocol. */
+export interface AppStateSyncKey {
+    key_data: Uint8Array;
+    fingerprint: Uint8Array;
+    timestamp: number | string;
+}
+
+export interface ArchiveUpdate {
+    /** The chat being archived or unarchived. */
+    jid: Jid;
+    timestamp: number;
+    action: ArchiveChatAction;
+    from_full_sync: boolean;
+}
+
+/** How a [`MessageBatch`] was delivered. This describes the delivery shape, not a message's provenance: whether a stanza came from the offline queue is `info.is_offline` on each [`InboundMessage`]. */
+export type BatchOrigin = "Live" | "OfflineDrain";
+
+/** Action to perform on a blocklist entry. */
+export type BlocklistAction = "block" | "unblock";
+
+export type BotEditType = "first" | "inner" | "last";
+
+export type BusinessHourMode = "open_24h" | "specific_hours" | "appointment_only" | string;
+
+/** Parsed `<notification type="business">` stanza. */
+export interface BusinessNotification {
+    from: Jid;
+    stanza_id: string;
+    timestamp: number | string;
+    notification_type: BusinessNotificationType;
+    jid?: Jid | null;
+    hash?: string | null;
+    verified_name?: VerifiedName | null;
+    product_ids: string[];
+    collection_ids: string[];
+    subscriptions: BusinessSubscription[];
+}
+
+/** Business notification type based on child element. */
+export type BusinessNotificationType = "remove_jid" | "remove_hash" | "verified_name_jid" | "verified_name_hash" | "profile" | "profile_hash" | "product" | "collection" | "subscriptions" | "unknown";
+
+/** Business status update notification. */
+export interface BusinessStatusUpdate {
+    /** The business account whose status changed. */
+    jid: Jid;
+    update_type: BusinessUpdateType;
+    timestamp: number;
+    target_jid?: Jid | null;
+    hash?: string | null;
+    verified_name?: string | null;
+    product_ids: string[];
+    collection_ids: string[];
+    subscriptions: BusinessSubscription[];
+}
+
+/** Business subscription information (SMB features). */
+export interface BusinessSubscription {
+    id: string;
+    status: string;
+    expiration_date?: number | string | null;
+    creation_time?: number | string | null;
+}
+
+/** Type of business status update. */
+export type BusinessUpdateType = "removed_as_business" | "verified_name_changed" | "profile_updated" | "products_updated" | "collections_updated" | "subscriptions_updated" | "unknown";
+
+/** Minimal cached form of a Noise certificate. Mirrors the JSON shape WA Web persists in `waNoiseInfo.certificateChainBuffer` (only `key` plus the validity window — signatures and issuer_serial are intentionally dropped). */
+export interface CachedNoiseCert {
+    /** 32-byte X25519 public key from `NoiseCertificate.Details.key`. */
+    key: Uint8Array;
+    /** Unix epoch seconds. Validation window from `NoiseCertificate.Details`. */
+    not_before: number | string;
+    not_after: number | string;
+}
+
+/** Cached form of the server's two-cert chain. `leaf.key` is the server static public key consumed by Noise IK; the intermediate is kept solely to mirror WA Web's expiry checks. */
+export interface CachedServerCertChain {
+    intermediate: CachedNoiseCert;
+    leaf: CachedNoiseCert;
+}
+
+/** Fields kept per-variant (not a shared `BasicCallMeta`) so the `serde` shape mirrors the stanza 1:1 for downstream JS consumers. */
+export type CallAction =
+| { type: "offer"; call_id: string; call_creator: Jid; caller_pn?: Jid | null; caller_country_code?: string | null; device_class?: string | null; joinable: boolean; is_video: boolean; audio: CallAudioCodec[]; group_jid?: Jid | null }
+| { type: "offer_notice"; call_id: string; call_creator: Jid; is_video: boolean; is_group: boolean }
+| { type: "preaccept"; call_id: string; call_creator: Jid; audio: CallAudioCodec[] }
+| { type: "accept"; call_id: string; call_creator: Jid; audio: CallAudioCodec[] }
+| { type: "reject"; call_id: string; call_creator: Jid; reason?: string | null }
+| { type: "terminate"; call_id: string; call_creator: Jid; reason?: string | null; duration?: number | null; audio_duration?: number | null }
+| { type: "transport"; call_id: string; call_creator: Jid; p2p_cand_round?: string | null; transport_message_type?: string | null }
+| { type: "relaylatency"; call_id: string; call_creator: Jid }
+| { type: "video"; call_id: string; call_creator: Jid; state: VideoState; orientation?: number | null; dec?: string | null }
+| { type: "group_update"; update: GroupCallUpdate }
+| { type: "enc_rekey"; rekey: GroupCallEncRekey }
+| { type: "waiting_room_update"; room: WaitingRoom }
+| { type: "user_action"; call_id: string; call_creator: Jid; raised: boolean }
+| { type: "screen_share"; call_id: string; call_creator: Jid; screen_share: ScreenShare };
+
+export interface CallAudioCodec {
+    enc: string;
+    rate: number;
+}
+
+/** An incoming call we were ringing for was resolved on ANOTHER of our devices (multi-device): the caller dismissed this device with a `<terminate reason="accepted_elsewhere"|"rejected_elsewhere">`. Distinct from [`MissedCall`] (a genuinely unanswered call) so a consumer can render "answered on another device" instead of a missed call. Mirrors WA Web's AcceptedElsewhere / Rejected outcomes. */
+export interface CallEndedElsewhere {
+    from: Jid;
+    /** The call id (from the `<offer>` action); distinct from the `<call>` stanza id. */
+    call_id: string;
+    timestamp: number;
+    outcome: ElsewhereOutcome;
+}
+
+/** Result of creating a reusable call link. */
+export interface CallLink {
+    token: string;
+    media: CallLinkMedia;
+}
+
+/** Admission state returned after joining a reusable call link. */
+export interface CallLinkJoin {
+    token: string;
+    media: CallLinkMedia;
+    call_id: string;
+    call_creator: Jid;
+    waiting_room_enabled: boolean;
+    in_waiting_room: boolean;
+    is_admin: boolean;
+    waiting_room?: WaitingRoom | null;
+    group?: GroupCallUpdate | null;
+}
+
+/** Audio/video mode of a reusable call link. */
+export type CallLinkMedia = "audio" | "video";
+
+/** Metadata returned without joining a reusable call link. */
+export interface CallLinkPreview {
+    token: string;
+    media: CallLinkMedia;
+    creator: Jid;
+    creator_pn?: Jid | null;
+    waiting_room_enabled: boolean;
+    is_admin: boolean;
+}
+
+/** Identifies a specific message within a chat. */
+export interface ChatMessageId {
+    chat: Jid;
+    id: string;
+}
+
+export type ChatPresence = "composing" | "paused";
+
+export type ChatPresenceMedia = "" | "audio";
+
+export interface ChatPresenceUpdate {
+    source: MessageSource;
+    state: ChatPresence;
+    media: ChatPresenceMedia;
+}
+
+/** Chat state type for typing indicators. */
+export type ChatStateType = "composing" | "recording" | "paused";
+
+/** A chat's messages were cleared (kept) on a linked device. */
+export interface ClearChatUpdate {
+    /** The chat being cleared. */
+    jid: Jid;
+    /** From the index, not the proto — ClearChatAction only has messageRange. */
+    delete_starred: boolean;
+    /** From the index, not the proto. */
+    delete_media: boolean;
+    timestamp: number;
+    action: ClearChatAction;
+    from_full_sync: boolean;
+}
+
+export interface ClientOutdated {
+    /** The whole `<failure>` stanza, so no attribute is lost to a log line. */
+    raw?: any | null;
+}
+
+export interface ConnectFailure {
+    reason: ConnectFailureReason;
+    /** The server's `message` attribute on the `<failure>` stanza, when present. */
+    message?: string | null;
+    raw?: any | null;
+}
+
+/** Wire codes: 400=Generic, 401=LoggedOut, 402=TempBanned, 403=AccountLocked, 406=UnknownLogout, 405=ClientOutdated, 409=BadUserAgent, 413=CatExpired, 414=CatInvalid, 415=NotFound, 418=ClientUnknown, 500=InternalServerError, 501=Experimental, 503=ServiceUnavailable */
+export type ConnectFailureReason = number;
+
+/** A contact changed their phone number.  Emitted from `<notification type="contacts"><modify old="..." new="..." old_lid="..." new_lid="..."/>`.  The library updates the global LID-PN cache when both `old_lid` and `new_lid` are present, mirroring `WAWebDBCreateLidPnMappings`. No Signal session is wiped (WA Web `WAWebHandleContactNotification` also leaves sessions intact). Group participant updates arrive via separate `w:gp2` notifications, so per-group caches are not touched here. Consumers can subscribe and refresh their own caches if needed. */
+export interface ContactNumberChanged {
+    /** Old phone number JID. */
+    old_jid: Jid;
+    /** New phone number JID. */
+    new_jid: Jid;
+    /** Old LID (if provided by server). */
+    old_lid?: Jid | null;
+    /** New LID (if provided by server). */
+    new_lid?: Jid | null;
+    timestamp: number;
+}
+
+/** Server requests a full contact re-sync.  Emitted from `<notification type="contacts"><sync after="..."/>`. */
+export interface ContactSyncRequested {
+    after?: number | null;
+    timestamp: number;
+}
+
+export interface ContactUpdate {
+    /** The chat/contact this sync action applies to. */
+    jid: Jid;
+    timestamp: number;
+    action: ContactAction;
+    from_full_sync: boolean;
+}
+
+/** A contact's profile changed (server notification).  Emitted from `<notification type="contacts"><update jid="..."/>`. WA Web resets cached presence and refreshes the profile picture on this event — consumers should invalidate any cached presence/profile data.  Not to be confused with [`ContactUpdate`] which comes from app-state sync mutations (different source, different payload). */
+export interface ContactUpdated {
+    /** The contact whose profile was updated. */
+    jid: Jid;
+    timestamp: number;
+}
+
+export type DayOfWeek = "sun" | "mon" | "tue" | "wed" | "thu" | "fri" | "sat" | string;
+
+export type DecryptFailMode = "show" | "hide";
+
+export interface DeleteChatUpdate {
+    /** The chat being deleted. */
+    jid: Jid;
+    /** From the index, not the proto — DeleteChatAction only has messageRange. */
+    delete_media: boolean;
+    timestamp: number;
+    action: DeleteChatAction;
+    from_full_sync: boolean;
+}
+
+export interface DeleteMessageForMeUpdate {
+    /** The chat containing the deleted message. */
+    chat_jid: Jid;
+    participant_jid?: Jid | null;
+    message_id: string;
+    from_me: boolean;
+    timestamp: number;
+    action: DeleteMessageForMeAction;
+    from_full_sync: boolean;
+}
+
+export interface Device {
+    pn?: Jid | null;
+    lid?: Jid | null;
+    registration_id: number;
+    noise_key: KeyPair;
+    identity_key: KeyPair;
+    signed_pre_key: KeyPair;
+    signed_pre_key_id: number;
+    signed_pre_key_signature: Uint8Array;
+    adv_secret_key: Uint8Array;
+    account?: ADVSignedDeviceIdentity | null;
+    push_name: string;
+    app_version_primary: number;
+    app_version_secondary: number;
+    app_version_tertiary: number;
+    app_version_last_fetched_ms: number | string;
+    /** Edge routing info received from server, used for optimized reconnection. When present, this should be sent as a pre-intro before the Noise handshake. */
+    edge_routing_info?: Uint8Array | null;
+    /** Hash from the last props (A/B experiment config) fetch. Sent on subsequent connects to enable delta updates instead of full fetches. */
+    props_hash?: string | null;
+    /** Monotonically increasing counter for one-time pre-key ID generation. Matches WhatsApp Web's `NEXT_PK_ID` pattern: only increases, never resets. Advances at GENERATION time (WA Web `savePreKeys`), so it covers every key that exists in the store, uploaded or not. */
+    next_pre_key_id: number;
+    /** Watermark of the first generated-but-not-yet-uploaded one-time prekey, matching WA Web's `FIRST_UNUPLOAD_PK_ID`. `next_pre_key_id - this` is the pool of leftover keys an upload re-offers before generating new ones. `0` = unset (legacy device); initialised on the first upload. */
+    first_unupload_pre_key_id: number;
+    /** Persisted flag matching WA Web's `signal_sever_has_pre_keys` metadata. */
+    server_has_prekeys: boolean;
+    /** NCT salt provisioned by the server via app state sync or history sync. */
+    nct_salt?: Uint8Array | null;
+    /** Server cert chain cached from the last successful XX (or XX-fallback) handshake. Enables Noise IK on the next connect by exposing `leaf.key` as the server's static public key, and lets us reject stale entries via `not_after` before even attempting IK. `None` forces XX on the next connect. */
+    server_cert_chain?: CachedServerCertChain | null;
+    /** Login counter sent as `ClientPayload.lc` on every login. WA Web's `WAWebUserPrefsGeneral.getLoginCounter()` reads (and bumps) this from localStorage on each connect; the server uses it as an anti-abuse signal. Persisted so it survives restarts. */
+    login_counter: number;
+    /** WA Web's `WAIsAccountLidFieldMigrated` pref: whether the account is 1:1-LID-migrated. Set from `ClientPairingProps.isChatDbLidMigrated` at pair time or when the primary pushes migration mappings. Gates outbound DM wire addressing (LID vs PN); the Signal session layer stays LID-first regardless, mirroring WAWebSignalAddress. Once set it never reverts, like the WA Web pref. */
+    lid_migrated: boolean;
+    /** Wall-clock ms of the last signed-pre-key rotation, driving WA Web's `RotateKeyJob` cadence. Fresh devices baseline off creation; devices persisted before this field existed deserialize to `0`, which the rotation path treats as "seed the baseline, don't rotate yet". */
+    last_signed_pre_key_rotation_ms: number | string;
+    /** true means the account's `readreceipts` privacy is `none`, so DM read/played receipts go out as `*-self` (which don't notify the sender). Persisted so the value is known on reconnect before the privacy fetch completes; `false` (WA default `all`) sends plain `read`/`played`. */
+    read_receipts_disabled: boolean;
+}
+
+/** Device element from notification.  Wire format: ```xml <device jid="185169143189667:75@lid" key-index="2" lid="..."/> ```  Device ID is extracted from the JID's device part (e.g., 75 from "user:75@lid").  Per WhatsApp Web: if both `jid` and `lid` attributes are present, the device IDs must match or the notification is rejected. */
+export interface DeviceElement {
+    /** Device JID (contains user and device ID) */
+    jid: Jid;
+    /** Optional key index */
+    key_index?: number | null;
+    /** Optional LID (device ID must match jid's device ID if present) */
+    lid?: Jid | null;
+}
+
+/** Device information for registry tracking. */
+export interface DeviceInfo {
+    /** The device ID (0 = primary device, 1+ = companion devices) */
+    device_id: number;
+    /** The key index, if known */
+    key_index?: number | null;
+    /** Whether the device uses the hosted PN/LID address space. */
+    is_hosted: boolean;
+}
+
+/** Device list record matching WhatsApp Web's DeviceListRecord structure. */
+export interface DeviceListRecord {
+    /** The user part of the JID (phone number or LID) */
+    user: string;
+    /** List of known devices for this user */
+    devices: DeviceInfo[];
+    /** Timestamp when this record was last updated */
+    timestamp: number | string;
+    /** Participant hash from usync, if available */
+    phash?: string | null;
+    /** ADV raw_id from `ADVKeyIndexList` — used to detect identity changes. When this changes, all sessions and sender keys for the user must be cleared. */
+    raw_id?: number | null;
+}
+
+/** Device list update notification. Emitted when a user's device list changes (device added/removed/updated). */
+export interface DeviceListUpdate {
+    /** The user whose device list changed (from attribute) */
+    user: Jid;
+    /** Optional LID user (for LID-PN mapping) */
+    lid_user?: Jid | null;
+    /** Type of update (add/remove/update) */
+    update_type: DeviceListUpdateType;
+    /** Affected devices with detailed info */
+    devices: DeviceNotificationInfo[];
+    /** Key index info (for add/remove) */
+    key_index?: KeyIndexInfo | null;
+    /** Contact hash (for update - used for contact lookup) */
+    contact_hash?: string | null;
+}
+
+/** Type of device list update notification. Matches WhatsApp Web's device notification types. */
+export type DeviceListUpdateType = "add" | "remove" | "update";
+
+/** Parsed device notification stanza.  Wire format: ```xml <notification from="185169143189667@lid" id="..." t="..." type="devices" lid="..."> <remove> <device jid="185169143189667:75@lid"/> <key-index-list ts="1769296600"/> </remove> </notification> ```  Reference: WhatsApp Web `WAWebHandleDeviceNotification` parser (5Yec01dI04o.js:23125-23183)  Per WhatsApp Web: Only ONE operation per notification is processed. Priority order: remove > add > update */
+export interface DeviceNotification {
+    /** User JID (from attribute) */
+    from: Jid;
+    /** Optional LID user (for LID-PN mapping learning) */
+    lid_user?: Jid | null;
+    /** Stanza ID (for ACK) */
+    stanza_id: string;
+    /** Timestamp */
+    timestamp: number | string;
+    /** The operation (one per notification, priority: remove > add > update) */
+    operation: DeviceOperation;
+}
+
+/** Device information from notification. */
+export interface DeviceNotificationInfo {
+    /** Device ID (extracted from JID) */
+    device_id: number;
+    /** Optional key index */
+    key_index?: number | null;
+}
+
+/** Device notification operation type.  Wire format: Child element tag of `<notification type="devices">` - `<add>` - Device was added - `<remove>` - Device was removed - `<update>` - Device info updated (hash-based lookup) */
+export type DeviceNotificationType = "add" | "remove" | "update";
+
+/** Operation content (add/remove/update child element).  Wire format per WhatsApp Web (5Yec01dI04o.js:23141-23180): ```xml <add> <device jid="user:75@lid" key-index="2"/> <key-index-list ts="...">SIGNED_BYTES</key-index-list> </add> <!-- OR --> <remove> <device jid="user:75@lid"/> <key-index-list ts="..."/>  <!-- ts required for remove --> </remove> <!-- OR --> <update hash="CONTACT_HASH"/> ```  Note: WhatsApp Web does NOT read any attributes from add/remove nodes. The `device_hash` attribute (if present) is not used by the official client. */
+export interface DeviceOperation {
+    /** Operation type (add/remove/update) */
+    operation_type: DeviceNotificationType;
+    /** Contact hash (for update only) - from `hash` attribute, used for contact lookup */
+    contact_hash?: string | null;
+    /** Device elements (for add/remove, single device per WhatsApp Web) */
+    devices: DeviceElement[];
+    /** Key index info (required for add/remove per WhatsApp Web) */
+    key_index?: KeyIndexInfo | null;
+}
+
+export interface DeviceSentMeta {
+    destination_jid: string;
+    phash: string;
+}
+
+/** A valid `<ib><dirty>` marker received from the server.  The client still performs its built-in clean/resync work; this event lets consumers refresh domain-specific derived state without observing every raw stanza. */
+export interface DirtyState {
+    dirty_type: DirtyType;
+    timestamp?: number | string | null;
+}
+
+export type DirtyType = "account_sync" | "groups" | "syncd_app_state" | "newsletter_metadata" | string;
+
+export type DisallowedListAction = "add" | "remove";
+
+/** A contact's default disappearing messages setting changed.  Sent by the server as `<notification type="disappearing_mode">`. WA Web: `WAWebHandleDisappearingModeNotification` → `WAWebUpdateDisappearingModeForContact`. */
+export interface DisappearingModeChanged {
+    /** The contact whose setting changed. */
+    from: Jid;
+    /** New duration in seconds (0 = disabled, 86400 = 24h, etc.). */
+    duration: number;
+    /** When the setting was changed. Consumers should only apply this if it's newer than their stored value. */
+    setting_timestamp: number;
+}
+
+/** Why the transport connection ended. Lets a benign server-initiated stream recycle (a clean Close frame) be told apart from an abrupt EOF or a real read error when diagnosing reconnect behavior.  Serialize: carried by `events::Disconnected`, whose payload consumers forward as JSON (webhooks, dashboards) — snake_case so the wire shape doesn't leak Rust variant naming. */
+export type DisconnectReason =
+| { "server_close": { code?: number | null; reason: string } }
+| "stream_ended"
+| { "read_error": string }
+| "unknown";
+
+export interface Disconnected {
+    /** Why the transport ended — lets consumers tell a routine server stream recycle (`reason.is_clean_shutdown()`) from a genuine transport failure without parsing logs. */
+    reason: DisconnectReason;
+}
+
+export type EditAttribute = "" | "1" | "2" | "3" | "7" | "8" | string;
+
+/** Which terminal outcome another of our devices reached for a call we were ringing for. */
+export type ElsewhereOutcome = "accepted" | "rejected";
+
+/** Review state for an appeal on a suspended group. */
+export type GroupAppealStatus = "approved" | "in_review" | "none" | "rejected";
+
+/** One device in an authoritative group-call roster. */
+export interface GroupCallDevice {
+    jid: Jid;
+    platform?: string | null;
+    pid?: number | null;
+    capability_version?: number | null;
+}
+
+/** One encrypted keygen-v2 epoch delivered to a participant device. */
+export interface GroupCallEncRekey {
+    call_id: string;
+    call_creator: Jid;
+    transaction_id: number;
+    key_generation: number;
+    encryption_type: string;
+    encryption_version: number;
+}
+
+/** One user in an authoritative group-call roster. */
+export interface GroupCallParticipant {
+    jid: Jid;
+    state?: string | null;
+    participant_type?: string | null;
+    devices: GroupCallDevice[];
+}
+
+/** Shared relay allocation embedded in a group snapshot. */
+export interface GroupCallRelay {
+    transaction_id?: number | null;
+    self_pid?: number | null;
+    uuid: string;
+    participant_uuid: string;
+    attribute_padding: boolean;
+    warp_mi_tag_len?: number | null;
+    endpoints: GroupCallRelayEndpoint[];
+}
+
+/** One address advertised by the shared group relay. */
+export interface GroupCallRelayEndpoint {
+    relay_id: number;
+    token_id: number;
+    auth_token_id: number;
+    relay_name: string;
+    domain_name?: string | null;
+    rtt_ms?: number | null;
+    is_fna: boolean;
+    ipv4?: string | null;
+    port?: number | null;
+}
+
+/** One transaction-ordered authoritative group-call snapshot. */
+export interface GroupCallUpdate {
+    call_id: string;
+    call_creator: Jid;
+    group_jid?: Jid | null;
+    transaction_id: number;
+    media: string;
+    connected_limit: number;
+    joinable: boolean;
+    av_upgradable: boolean;
+    rekey_requested: boolean;
+    participants: GroupCallParticipant[];
+    relay?: GroupCallRelay | null;
+}
+
+/** Delivery state for history shared with a newly joined participant. */
+export type GroupHistorySentState = "HISTORY_NOT_SENT" | "HISTORY_SENT" | "NOTICE_SENT";
+
+export interface GroupInfo {
+    participants: Jid[];
+    addressing_mode: AddressingMode;
+    /** Whether this group is a Community Announcement Group (WA Web `isCag`, derived from `default_sub_group`). `None` means the persisted blob predates the field, so the answer is unknown and callers must re-query. */
+    is_community_announce?: boolean | null;
+    /** Maps a LID user identifier (the `user` part of the LID JID) to the corresponding phone-number JID. This is used for device queries since LID usync requests may not work reliably. */
+    lid_to_pn_map: Record<string, Jid>;
+}
+
+/** All possible group notification action types.  Maps 1:1 to `GROUP_NOTIFICATION_TAG` child element tags from WhatsApp Web.  The `#[wire = "..."]` attribute is the SINGLE source of truth for each variant's wire tag: the JSON discriminator (via the auto-derived `Serialize`), the parser dispatch (via the auto-generated sibling `GroupNotificationActionTag` enum), and `wire_tag()` / `tag_name()` all read from the same table. */
+export type GroupNotificationAction =
+| { type: "add"; participants: GroupParticipantInfo[]; reason?: string | null }
+| { type: "remove"; participants: GroupParticipantInfo[]; reason?: string | null }
+| { type: "promote"; participants: GroupParticipantInfo[] }
+| { type: "demote"; participants: GroupParticipantInfo[] }
+| { type: "modify"; participants: GroupParticipantInfo[] }
+| { type: "subject"; subject: string; subject_owner?: Jid | null; subject_time?: number | string | null }
+| { type: "description"; id: string; description?: string | null }
+| { type: "locked"; threshold?: string | null }
+| { type: "unlocked" }
+| { type: "announcement" }
+| { type: "not_announcement" }
+| { type: "ephemeral"; expiration: number; trigger?: number | null }
+| { type: "membership_approval_mode"; enabled: boolean }
+| { type: "membership_approval_request"; request_method: MembershipRequestMethod; parent_group_jid?: Jid | null }
+| { type: "created_membership_requests"; request_method: MembershipRequestMethod; parent_group_jid?: Jid | null; requests: GroupParticipantInfo[] }
+| { type: "revoked_membership_requests"; participants: Jid[] }
+| { type: "member_add_mode"; mode: string }
+| { type: "no_frequently_forwarded" }
+| { type: "frequently_forwarded_ok" }
+| { type: "invite"; code: string }
+| { type: "revoke" }
+| { type: "growth_locked"; expiration: number; lock_type: string }
+| { type: "growth_unlocked" }
+| { type: "create" }
+| { type: "delete"; reason?: string | null }
+| { type: "link"; link_type: string }
+| { type: "unlink"; unlink_type: string; unlink_reason?: string | null }
+| { type: "linked_group_promote"; participants: GroupParticipantInfo[] }
+| { type: "linked_group_demote"; participants: GroupParticipantInfo[] }
+| { type: "suspended" }
+| { type: "unsuspended" }
+| { type: "auto_add_disabled" }
+| { type: "is_capi_hosted_group" }
+| { type: "group_safety_check" }
+| { type: "limit_sharing_enabled"; trigger?: number | null }
+| { type: "allow_admin_reports" }
+| { type: "not_allow_admin_reports" }
+| { type: "reports" }
+| { type: "allow_non_admin_sub_group_creation" }
+| { type: "not_allow_non_admin_sub_group_creation" }
+| { type: "created_sub_group_suggestion" }
+| { type: "revoked_sub_group_suggestions" }
+| { type: "change_number"; new_owner?: Jid | null; sub_group_suggestions: Jid[] }
+| { type: string; tag: string };
+
+/** Participant info extracted from `<participant>` child elements.  Wire format: ```xml <participant jid="..." type="..." lid="..." phone_number="..." username="..." display_name="..." join_time="..."/> ```  `display_name` is the server-rendered label (e.g. `"+55∙∙∙∙∙∙∙∙∙79"` when the requester is not in the participant's contacts). `type` flags admin/superadmin tier; LID-addressed groups also carry `lid` and `username`. WA Web's `WAWebHandleGroupNotification` y() reads all of these into the participant model so the UI can render notifications and patch admin caches without resolving the contact locally. */
+export interface GroupParticipantInfo {
+    jid: Jid;
+    phone_number?: Jid | null;
+    /** Server-provided display label for this participant. Only populated for `<participant>` children inside group notifications; `None` for `<requested_user>` (WA Web doesn't read it there either). */
+    display_name?: string | null;
+    /** Admin tier. Defaults to `Participant` when the attr is missing. */
+    type?: GroupParticipantType | null;
+    /** LID JID when this `<participant>` carries a separate `lid` attr. Distinct from `jid` which may already be a LID. */
+    lid?: Jid | null;
+    /** Username, gated by `WAWebUsernameGatingUtils`. Empty in classic PN-addressed groups. */
+    username?: string | null;
+    /** Unix seconds since the participant joined the group. Used by admin UI for tenure display. */
+    join_time?: number | string | null;
+    /** Delivery state for post-join group history. */
+    group_history_sent_state?: GroupHistorySentState | null;
+}
+
+/** Admin tier from `<participant type="...">`. Mirrors `GROUP_PARTICIPANT_TYPES` in `WAWebGroupApiConst`. */
+export type GroupParticipantType = "participant" | "admin" | "superadmin";
+
+/** Query request type. */
+export type GroupQueryRequestType = "interactive";
+
+/** Group update notification.  Emitted for each action in a `<notification type="w:gp2">` stanza. A single notification may produce multiple `GroupUpdate` events (one per action). */
+export interface GroupUpdate {
+    /** The group this update applies to */
+    group_jid: Jid;
+    /** Identifier of the source notification stanza. */
+    notification_id?: string | null;
+    /** Display name supplied with the source notification. */
+    notify?: string | null;
+    /** Raw offline-delivery marker supplied with the source notification. */
+    offline?: string | null;
+    /** Zero-based emitted-action index within the source notification. */
+    action_index: number;
+    /** The admin/user who triggered the change (`participant` attribute) */
+    participant?: Jid | null;
+    /** Phone number JID of the participant (for LID-addressed groups) */
+    participant_pn?: Jid | null;
+    /** Username of the participant, when supplied by the group notification. */
+    participant_username?: string | null;
+    /** Country code supplied for the participant by the server. */
+    participant_country_code?: string | null;
+    /** When the change occurred */
+    timestamp: number;
+    /** Whether the group uses LID addressing mode */
+    is_lid_addressing_mode: boolean;
+    /** Whether participant identity information was incomplete in the source stanza. */
+    has_incomplete_participant_information: boolean;
+    /** The specific action */
+    action: GroupNotificationAction;
+}
+
+export type HostType = "primary" | "fallback" | string;
+
+/** Identity key changed for a user (e.g., user reinstalled WhatsApp). Emitted after device record cleanup so sessions and sender keys are cleared. */
+export interface IdentityChange {
+    /** The user whose identity changed */
+    user: Jid;
+    /** Optional LID for the user */
+    lid_user?: Jid | null;
+    /** `true` when detected locally while saving a peer's new identity during decrypt (mirrors WA Web `saveIdentity` -> `handleNewIdentity`), `false` when triggered by the server's `<identity/>` notification. */
+    implicit: boolean;
+}
+
+/** One decrypted inbound message. The same items (and order) back both consumer surfaces: the durability hook's batch and [`Event::Messages`]. */
+export interface InboundMessage {
+    message: any;
+    info: MessageInfo;
+}
+
+export interface IncomingCall {
+    from: Jid;
+    /** Stanza id; distinct from `CallAction::call_id`. */
+    stanza_id: string;
+    notify?: string | null;
+    platform?: string | null;
+    version?: string | null;
+    /** Companion-routing metadata copied from the outer `<call>` wrapper. */
+    participant?: Jid | null;
+    /** Companion recipient metadata copied from the outer `<call>` wrapper. */
+    recipient?: Jid | null;
+    timestamp: number;
+    offline: boolean;
+    action: CallAction;
+    /** Group snapshot embedded in an initial offer or active-call invitation. */
+    group?: GroupCallUpdate | null;
+}
+
+/** IQ request type for WhatsApp protocol queries. */
+export type InfoQueryType = "set" | "get";
+
+/** Key index information from `<key-index-list>` element.  Wire format: ```xml <!-- For add: has signed bytes content --> <key-index-list ts="1769296600">SIGNED_BYTES</key-index-list> <!-- For remove: empty, ts required --> <key-index-list ts="1769296600"/> ```  Required for add/remove operations per WhatsApp Web. */
+export interface KeyIndexInfo {
+    /** Timestamp (required for remove per WhatsApp Web) */
+    timestamp: number | string;
+    /** Signed key index bytes (only present for add) */
+    signed_bytes?: Uint8Array | null;
+}
+
+/** A label was associated with or removed from a chat on a linked device. `action.labeled == Some(true)` means the label was added to the chat. */
+export interface LabelAssociationUpdate {
+    /** The label identifier. */
+    label_id: string;
+    /** The chat the label was associated with or removed from. */
+    chat_jid: Jid;
+    timestamp: number;
+    action: LabelAssociationAction;
+    from_full_sync: boolean;
+}
+
+/** A label was created, renamed/recolored, or deleted on a linked device. `action.deleted == Some(true)` means the label was removed. */
+export interface LabelEditUpdate {
+    /** The label identifier (the index key, not a JID). */
+    label_id: string;
+    timestamp: number;
+    action: LabelEditAction;
+    from_full_sync: boolean;
+}
+
+/** The source from which a LID-PN mapping was learned.  The source is load-bearing, not just provenance: it selects the write policy applied when the pair reaches the cache — see `lid_pn_write_policy` in the `whatsapp-rust` client, which mirrors WhatsApp Web's `createLidPnMappings` `switch (learningSource)`. Directed sources overwrite on any change; observational bulk sources (`Other` and friends, WA Web `"other"`) only seed new LIDs and re-resolve conflicts via a live query; known-stale sources are stamped `created_at = 0` so they never outrank a fresher mapping for the same phone (the PN→LID resolution direction; the LID→PN reverse map always takes the latest write). */
+export type LearningSource = "usync" | "peer_pn_message" | "peer_lid_message" | "recipient_latest_lid" | "migration_sync_latest" | "migration_sync_old" | "blocklist_active" | "blocklist_inactive" | "pairing" | "device_notification" | "other";
+
+/** An entry in the LID-PN cache containing the full mapping information. */
+export interface LidPnEntry {
+    /** The LID user part (e.g., "100000012345678"). `Arc<str>`: the cache stores each mapping under both directions, so the identifier strings are shared between the entry and the cache keys instead of re-allocated per copy (this cache is unbounded by design). */
+    lid: string;
+    /** The phone number user part (e.g., "559980000001") */
+    phone_number: string;
+    /** Unix timestamp when the mapping was first learned */
+    created_at: number | string;
+    /** The source from which this mapping was learned */
+    learning_source: LearningSource;
+}
+
+/** Entry representing a LID to Phone Number mapping. */
+export interface LidPnMappingEntry {
+    /** The LID user part (e.g., "100000012345678") */
+    lid: string;
+    /** The phone number user part (e.g., "559980000001") */
+    phone_number: string;
+    /** Unix timestamp when the mapping was first learned */
+    created_at: number | string;
+    /** Unix timestamp when the mapping was last updated */
+    updated_at: number | string;
+    /** The source from which this mapping was learned (e.g., "usync", "peer_pn_message") */
+    learning_source: string;
+}
+
+export interface LoggedOut {
+    on_connect: boolean;
+    reason: ConnectFailureReason;
+    /** Server-supplied logout copy, when it sent any. Present in practice on [`ConnectFailureReason::AccountLocked`]. */
+    logout_message?: LogoutMessage | null;
+    /** The whole stanza that caused the logout, when one did.  Two shapes reach here, so dispatch on `raw.tag` rather than assuming one: `<failure>` for a server-side refusal (`on_connect` is then true), and `<stream:error>` for a `<conflict>`, a 516 device removal or a 401. `None` when nothing was received at all — a locally initiated logout has no stanza to report.  A forced logout is where the server puts data it will never repeat: an account lock carries a one-time `appeal_token` plus `violation_reason` and `vt`, which WA Web ignores (its own appeal flow is native) but which an embedder cannot recover once the stanza is gone. Parsing policy stays with the consumer — `violation_reason` is not a closed set — but the bytes have to survive the dispatch. */
+    raw?: any | null;
+}
+
+/** Localized text the server wants shown when it forces a logout, from `logout_message_header` / `logout_message_subtext` on `<failure>`.  `locale` is what makes the text safe to render: WA Web (`WAWebHandleFailure`) shows the header/subtext only when the locale equals the client's current one, and otherwise falls back to its own generic copy. It travels with the text so a consumer can apply the same rule. */
+export interface LogoutMessage {
+    header?: string | null;
+    subtext?: string | null;
+    /** e.g. `"pt_BR"`. Compare against the consumer's locale before rendering. */
+    locale?: string | null;
+}
+
+export interface MarkChatAsReadUpdate {
+    /** The chat being marked as read or unread. */
+    jid: Jid;
+    timestamp: number;
+    action: MarkChatAsReadAction;
+    from_full_sync: boolean;
+}
+
+/** Member link mode for group invite links. */
+export type MemberLinkMode = "admin_link" | "all_member_link";
+
+/** Who can share message history with new members. */
+export type MemberShareHistoryMode = "admin_share" | "all_member_share";
+
+/** How a membership request was initiated.  Maps to `WAWebRequestMethodType` in WhatsApp Web JS. */
+export type MembershipRequestMethod = "invite_link" | "linked_group_join" | "non_admin_add";
+
+/** Payload of [`Event::Messages`]: the decrypted messages of one durable commit, in arrival order. Behaves as a collection of its messages — `for msg in &batch`, `batch.iter()`, `batch.len()` — with `origin` carrying the delivery shape alongside. */
+export interface MessageBatch {
+    messages: InboundMessage[];
+    origin: BatchOrigin;
+    /** Whether an inbound durability hook already committed these messages before this event was dispatched.  Orthogonal to [`origin`](Self::origin), which describes delivery shape: a hook commits live batches and drain batches alike. What this answers is whether the consumer's own durable copy already exists, so a materializer that the hook feeds can skip the batch instead of rewriting every row (and re-firing every invalidation) a second time.  `false` for the producers that dispatch `Event::Messages` while deliberately bypassing the commit pipeline — newsletters and PDO-recovered messages — because for those the materialization on this event is the only one there is. */
+    hook_committed: boolean;
+}
+
+export type MessageCategory = "" | "peer" | string;
+
+export interface MessageInfo {
+    source: MessageSource;
+    id: string;
+    server_id: number;
+    type: string;
+    push_name: string;
+    timestamp: number;
+    category: MessageCategory;
+    multicast: boolean;
+    media_type: string;
+    edit: EditAttribute;
+    bot_info?: MsgBotInfo | null;
+    meta_info: MsgMetaInfo;
+    /** Decoded `<verified_name>` child cert of business senders; the display name is in `.name`. Boxed: most messages carry none. */
+    verified_name?: VerifiedName | null;
+    device_sent_meta?: DeviceSentMeta | null;
+    /** Ephemeral duration in seconds, extracted from `contextInfo.expiration`. */
+    ephemeral_expiration?: number | null;
+    /** Whether this message was delivered during offline sync. */
+    is_offline: boolean;
+    /** Set when this message was recovered via PDO rather than normal decryption. Contains the PDO request message ID. */
+    unavailable_request_id?: string | null;
+    /** Server-store timestamp in microseconds (envelope `sts` attr). Used by WA Web for read-self watermark ordering across companion devices. */
+    server_timestamp_us?: number | string | null;
+    /** Envelope `verified_level` attr (e.g. "unknown"/"low"/"high"). For business messages this is the server-asserted verification tier; for regular messages it is absent. */
+    verified_level?: string | null;
+    /** Envelope `verified_name` int attr (business name certificate serial). Separate from the `verified_name` child cert bytes already on this struct. */
+    verified_name_serial?: number | string | null;
+    /** Envelope `peer_recipient_pn` attr. Present on companion-device self-synced DM stanzas to identify the peer's PN (so the receipt goes to the right routing target). */
+    peer_recipient_pn?: Jid | null;
+    /** Parent post key when the dispatched message is a decrypted CAG channel comment (`enc_comment_message`). The inner `Message` proto has no slot for the threading link, so it surfaces here. */
+    comment_target?: MessageKey | null;
+    /** Broadcast-contact-list recipients from `<participants><to jid>` on an incoming broadcast/status stanza. Populated only for broadcasts; used to validate a `deviceSentMessage.phash` (WA Web `validateBclHash`). Empty otherwise. */
+    bcl_participants: Jid[];
+}
+
+export interface MessageSource {
+    chat: Jid;
+    sender: Jid;
+    is_from_me: boolean;
+    is_group: boolean;
+    addressing_mode?: AddressingMode | null;
+    sender_alt?: Jid | null;
+    recipient_alt?: Jid | null;
+    broadcast_list_owner?: Jid | null;
+    recipient?: Jid | null;
+}
+
+/** MEX GraphQL error extensions. */
+export interface MexErrorExtensions {
+    error_code?: number | null;
+    is_summary?: boolean | null;
+    is_retryable?: boolean | null;
+    severity?: string | null;
+}
+
+/** MEX GraphQL error. */
+export interface MexGraphQLError {
+    message: string;
+    extensions?: MexErrorExtensions | null;
+}
+
+/** `payload` shape depends on `op_name`. `offline` mirrors the raw string the server sets when replaying backlog (often a timestamp); presence alone signals backlog vs live. */
+export interface MexNotification {
+    op_name: string;
+    from?: Jid | null;
+    stanza_id?: string | null;
+    offline?: string | null;
+    payload: Value;
+}
+
+/** MEX GraphQL response. */
+export interface MexResponse {
+    data?: Value | null;
+    errors?: MexGraphQLError[] | null;
+}
+
+/** A call that must NOT ring: surfaced instead of [`IncomingCall`] so a consumer cannot auto-accept it. Currently this is an offer the server replayed from the offline queue on reconnect (the `<call>` carried the `offline` attribute) -- the call is long dead (no relay, not connectable). Mirrors WA Web's `cancel_call` + `missed_call` path for `offerReceivedWhileOffline`. */
+export interface MissedCall {
+    from: Jid;
+    /** The call id (from the `<offer>` action); distinct from the `<call>` stanza id. */
+    call_id: string;
+    timestamp: number;
+    reason: MissedReason;
+}
+
+/** Why a call surfaced as missed rather than ringing. */
+export type MissedReason = "offline" | "remote";
+
+export interface MsgBotInfo {
+    edit_type?: BotEditType | null;
+    edit_target_id?: string | null;
+    edit_sender_timestamp_ms?: number | null;
+}
+
+export interface MsgMetaInfo {
+    target_id?: string | null;
+    target_sender?: Jid | null;
+    /** `<meta target_chat_jid="…">` — present when the bot reply addresses a chat distinct from the stanza-level `from` (used for msmsg secret lookup; see WA Web `decryptMsmsgBotMessage`). */
+    target_chat?: Jid | null;
+    deprecated_lid_session?: boolean | null;
+    thread_message_id?: string | null;
+    thread_message_sender_jid?: Jid | null;
+    /** `<meta content_type=...>` attr. Server marks reactions/edits as `"add_on"`; mirrors `WAWebHandleMsgParser` b()'s metadata read. */
+    content_type?: string | null;
+    /** `<meta appdata=...>` attr. `"default"` is the only observed value. */
+    appdata?: string | null;
+    /** `<reporting><reporting_tag>` content bytes (16 or 20). Pre-requisite for the server-side report-abuse flow. */
+    reporting_tag?: Uint8Array | null;
+    /** `<reporting><reporting_token>` content bytes (16). Pre-requisite for the server-side report-abuse flow. */
+    reporting_token?: Uint8Array | null;
+    /** `v` attr on `<reporting_token>`. WA Web defaults to 1 when missing. */
+    reporting_token_version?: number | string | null;
+}
+
+/** Message-secret write entry keyed by chat, sender, and message ID. */
+export interface MsgSecretEntry {
+    /** Canonical non-AD chat JID. Shared across entries from the same history conversation instead of allocating one identical string per message. */
+    chat: string;
+    /** Canonical non-AD sender JID. Often aliases `chat` for direct messages. */
+    sender: string;
+    /** Message identifier. `Arc<str>` keeps entry clones used by buffered persistence cheap without changing the serialized representation. */
+    msg_id: string;
+    secret: MessageSecret;
+    /** Absolute unix-seconds retention deadline. `0` means never expire. Computed by the caller from the parent message's event time plus a per-add-on-kind horizon (see `MsgSecretRetention`). The store prunes rows whose deadline has passed; it does not know the horizon itself. */
+    expires_at: number | string;
+    /** Parent message event time (unix seconds), or `0` when unknown. Kept so the receive path can enforce the edit-processing window (`editTs < message_ts + window`) the same way WhatsApp Web does. */
+    message_ts: number | string;
+}
+
+export interface MuteUpdate {
+    /** The chat being muted or unmuted. */
+    jid: Jid;
+    timestamp: number;
+    action: MuteAction;
+    from_full_sync: boolean;
+}
+
+/** Wire codes: 421=StaleGroupAddressingMode, 475=NewChatMessagesCapped, 487=ParsingError, 488=UnrecognizedStanza, 489=UnrecognizedStanzaClass, 490=UnrecognizedStanzaType, 491=InvalidProtobuf, 493=InvalidHostedCompanionStanza, 495=MissingMessageSecret, 496=SignalErrorOldCounter, 499=MessageDeletedOnPeer, 500=UnhandledError, 550=UnsupportedAdminRevoke, 551=UnsupportedLIDGroup, 552=DBOperationFailed */
+export type NackReason = number;
+
+/** A newsletter live update notification, typically containing updated reaction counts for one or more messages. */
+export interface NewsletterLiveUpdate {
+    /** The newsletter channel this update belongs to. */
+    newsletter_jid: Jid;
+    messages: NewsletterLiveUpdateMessage[];
+}
+
+/** A single message entry in a newsletter live update. */
+export interface NewsletterLiveUpdateMessage {
+    server_id: number | string;
+    reactions: NewsletterLiveUpdateReaction[];
+}
+
+/** A reaction count in a newsletter live update. */
+export interface NewsletterLiveUpdateReaction {
+    code: string;
+    count: number | string;
+}
+
+export type NewsletterMessageType = "text" | "media" | "reaction" | "revoke" | "poll_creation" | "poll_vote" | "edit" | string;
+
+export interface OfflineSyncCompleted {
+    count: number;
+}
+
+/** `total` is authoritative; the per-kind counts need not sum to it. */
+export interface OfflineSyncPreview {
+    total: number;
+    app_data_changes: number;
+    messages: number;
+    notifications: number;
+    receipts: number;
+    calls: number;
+    statuses: number;
+}
+
+/** How the server refused a pair-code request, as a matchable status.  The five named variants are the complete set WA Web's own response parser accepts (`WASmaxInMdIqMixinErrors.parseIqMixinErrors`, reached from `WASmaxInMdCompanionHelloResponseError`); anything else makes its RPC throw "unknown error". They exist so a consumer can branch on the refusal instead of matching the formatted message, which is not a stable surface.  Both stages report through this, though they were read off `companion_hello` and the `companion_finish` parser is narrower — `WASmaxInMdCompanionFinishErrors` admits only `bad-request` and `internal-server-error`, and WA Web shows its generic failure for anything else. A code outside that pair is still classified here rather than discarded: what a consumer does about a refusal follows from the code, which is one namespace across both requests, and answering "nothing was refused" to a refusal we can read would be worse than naming it.  The numbers are the `code` attribute, and each is the enum's whole wire form — [`code()`](Self::code) is what `Serialize` emits and what `From<i32>` reads back. WA Web pairs each code with a literal `text` (`429`/`rate-overlimit`, `452`/`feature-not-available`, …) and rejects a response whose two disagree, so construct these through [`from_server`](Self::from_server) rather than from a code alone: it is the only constructor that sees both attributes, and the only one that can decline to classify.  WA Web branches on exactly two of them (`DevicePhoneNumberCodeScreen`, on `CompanionHelloError.type.name`): [`RateOverlimit`](Self::RateOverlimit) becomes "too many attempts, try again later" and [`FeatureNotAvailable`](Self::FeatureNotAvailable) becomes "not available to you yet, link with QR code instead". The rest share a generic "try again or link with the QR code". In every case it resets the linking flow and waits for the person to act — it never retries on its own, and never reads the `backoff` hint, so treat that value as the server's advice rather than a schedule WA Web is known to follow. Wire codes: 400=BadRequest, 403=Forbidden, 429=RateOverlimit, 452=FeatureNotAvailable, 500=InternalServerError */
+export type PairCodeRejection = number;
+
+export interface PairError {
+    id: Jid;
+    lid: Jid;
+    business_name: string;
+    platform: string;
+    error: string;
+}
+
+/** Payload for [`Event::PairPasskeyConfirmation`]. */
+export interface PairPasskeyConfirmation {
+    code: string;
+    skip_handoff_ux: boolean;
+}
+
+/** Payload for [`Event::PairPasskeyError`]. */
+export interface PairPasskeyError {
+    error: string;
+    continuation: boolean;
+}
+
+/** Payload for [`Event::PairPasskeyRequest`]. */
+export interface PairPasskeyRequest {
+    /** Verbatim `PublicKeyCredentialRequestOptions` JSON from the server. Pass it straight to a WebAuthn `get` (e.g. Android Credential Manager), or parse it with `whatsapp_rust::passkey::parse_request_options`. */
+    request_options_json: string;
+}
+
+export interface PairSuccess {
+    id: Jid;
+    lid: Jid;
+    business_name: string;
+    platform: string;
+}
+
+/** Generated pair code for phone number linking. User should enter this code on their phone in WhatsApp > Linked Devices. */
+export interface PairingCode {
+    /** The 8-character pairing code to display. */
+    code: string;
+    /** Approximate validity duration (~180 seconds). */
+    timeout: number;
+}
+
+/** A phone-number pair-code flow failed, so no linking will come of it.  The counterpart to [`PairingCode`] on the failure path, and the only surface that reports it when pairing is driven by `BotBuilder::with_pair_code` — that request runs in a detached task, so nothing returns its error to the caller. `Client::pair_with_code` dispatches this in addition to returning `Err`, matching how the success path both returns the code and emits [`PairingCode`].  Both of the flow's server round trips report here, and the consumer's move is the same either way — this code is finished, request another or fall back to the QR. The later one arrives after a code was already displayed and entered: the phone answered, but the server refused the key bundle that answer produced. Silence at that stage is not this event, because nothing was refused; it surfaces as [`PairingCodeRefresh`] once the timer runs out.  Fires for every failure, including local validation (a phone number that is too short never reaches the server): a consumer waiting on a code needs to learn that it is not coming, whatever the reason. [`rejection`](Self::rejection) is what distinguishes the two — `None` means the request never got an answer from the server.  A claim the failed request itself took is released before this fires, so nothing is left holding the flow and `pair_with_code` can be called again.  Two failures do **not** arrive here, because for them a code may still be on its way and this event would say the opposite — a consumer acting on it would tear down a code that is about to arrive:  - `CodeAlreadyOutstanding` — refused precisely because an earlier code is still live, and the consumer already has it from the [`PairingCode`] that minted it. Retrying is futile until `cancel_pair_code` runs or the window closes. - `Cancelled` — the caller withdrew this request, and a replacement may already own the slot. A superseded request can return this *after* its replacement started, so the event would be uncorrelated with the flow that is actually running.  Both follow from something the caller did, so neither is news, and a direct caller still gets the `Err`.  Whether to retry at all is the point of the fields: back off on [`PairCodeRejection::is_throttled`](crate::pair_code::PairCodeRejection::is_throttled), stop on [`PairCodeRejection::FeatureNotAvailable`](crate::pair_code::PairCodeRejection::FeatureNotAvailable). */
+export interface PairingCodeError {
+    /** The server's refusal, when it answered with one. `None` when the failure was local (validation, no connection) or the request went unanswered (timeout) — nothing was refused, so there is no status to report. */
+    rejection?: PairCodeRejection | null;
+    /** How long the server asked the client to wait, from the `backoff` attribute. Usually absent — WA Web does not read it on this path — but when present it is the server naming its own retry delay, which beats any interval the consumer would pick. */
+    backoff?: number | null;
+    /** The failure rendered for logs. Do not branch on it; use [`rejection`](Self::rejection). */
+    error: string;
+}
+
+/** The in-progress phone-number pairing code should be replaced.  Emitted for the two cases WA Web regenerates on (`Alt/DeviceLinkingApi.js` + `Link/DevicePhoneNumberCodeScreen.react.js`): the server asking for it (`refreshAltLinkingCode` / `forceManualRefresh`, ref-gated against the outstanding flow), and a `companion_finish` that went unanswered for a minute — a primary that could not open the key bundle just goes quiet, so silence is the only signal there is.  The outstanding flow is cleared before this fires, so the consumer can call `pair_with_code` straight away. The previous code is no longer valid. */
+export interface PairingCodeRefresh {
+    /** `true` when the server set `force_manual_refresh` — the code must be re-requested explicitly rather than auto-rotated. */
+    force_manual: boolean;
+}
+
+/** A QR code the consumer renders during multi-device pairing. */
+export interface PairingQrCode {
+    /** The QR payload to render. */
+    code: string;
+    /** How long this code stays valid before the next one rotates in. */
+    timeout: number;
+}
+
+/** The server's `<pair-device>` refs are used up: there is no QR left to render until the connection is re-established.  WA Web's rotation timer (`Handle/PairDevice.js`) reports `UNPAIRED_IDLE` here and stops — it does not close the socket, because an alt-linking (phone-number) flow may still be riding the same connection. */
+export interface PairingQrCodesExhausted {
+    /** `true` when the client closed the connection itself, which it only does with no pair-code flow outstanding. `false` means the socket was left up and reconnecting is the consumer's call. */
+    disconnected: boolean;
+}
+
+/** Participant type (admin level). */
+export type ParticipantType = "member" | "admin" | "superadmin";
+
+export interface PictureUpdate {
+    /** The JID whose picture changed (user or group). */
+    jid: Jid;
+    /** The user who made the change. Present for group picture changes (the admin who changed it). `None` for personal picture updates. */
+    author?: Jid | null;
+    timestamp: number;
+    /** Whether the picture was removed (true) or set/updated (false). */
+    removed: boolean;
+    /** The server-assigned picture ID (from `<set id="..."/>`). `None` for deletions. */
+    picture_id?: string | null;
+}
+
+export interface PinUpdate {
+    /** The chat being pinned or unpinned. */
+    jid: Jid;
+    timestamp: number;
+    action: PinAction;
+    from_full_sync: boolean;
+}
+
+export type PreKeyFetchReason = "identity" | "retry" | string;
+
+export type Presence = "available" | "unavailable";
+
+export interface PresenceUpdate {
+    /** The contact whose presence changed. */
+    from: Jid;
+    unavailable: boolean;
+    last_seen?: number | null;
+}
+
+export type PrivacyCategory = "last" | "online" | "profile" | "status" | "groupadd" | "readreceipts" | "calladd" | "messages" | "defense" | string;
+
+export type PrivacySensitiveType = "1";
+
+export type PrivacyValue = "all" | "contacts" | "none" | "contact_blacklist" | "match_last_seen" | "known" | "off" | "on_standard" | string;
+
+/** Profile picture type (preview thumbnail or full-size). */
+export type ProfilePictureType = "preview" | "image";
+
+export interface PushNameUpdate {
+    /** The contact who changed their push name. */
+    jid: Jid;
+    message: MessageInfo;
+    old_push_name: string;
+    new_push_name: string;
+}
+
+export type PushPriority = "high" | "high_force";
+
+export interface Receipt {
+    source: MessageSource;
+    message_ids: string[];
+    timestamp: number;
+    type: ReceiptType;
+    /** True when the receipt carried the `offline` attribute, i.e. it was drained from the server's offline queue on reconnect rather than delivered live. Mirrors WA Web `incomingMsgReceiptParser` (`offline: maybeAttrString`). */
+    offline: boolean;
+}
+
+/** Chat state type as received from incoming stanzas.  Aligned with WhatsApp Web's `WAChatState` constants: - `typing` = ACTIVE_CHAT_STATE_TYPE.TYPING - `recording_audio` = ACTIVE_CHAT_STATE_TYPE.RECORDING_AUDIO - `idle` = IDLE_CHAT_STATE_TYPE.IDLE */
+export type ReceivedChatState = "typing" | "recording_audio" | "idle";
+
+/** Parsed screen-share state for one participant. */
+export interface ScreenShare {
+    state: ScreenShareState;
+    version: number;
+    screen_share_id?: number | null;
+}
+
+/** Wire state of a screen-share transition. Wire codes: 1=Started, 2=Stopped */
+export type ScreenShareState = number;
+
+export interface SelfPushNameUpdated {
+    from_server: boolean;
+    old_name: string;
+    new_name: string;
+}
+
+/** Payload of [`Event::ServerAck`]: the server acknowledged (or nacked) an outgoing stanza. Server acks cover every outgoing stanza class — message, receipt, notification, call — so consumers should filter on [`class`](Self::class) before correlating ids. */
+export interface ServerAck {
+    /** Id of the acked stanza (for a sent message, its message id). */
+    id: string;
+    /** Stanza class the ack refers to (`"message"`, `"receipt"`, `"notification"`, `"call"`, …). `None` when the server omits it. */
+    class?: string | null;
+    /** Chat/entity the ack refers to, when present and parseable. */
+    from?: Jid | null;
+    /** Server timestamp from the ack's `t` attribute, when present. For a message ack this is the authoritative send timestamp (whatsmeow reads the same attribute into `SendResponse.Timestamp`). */
+    timestamp?: number | null;
+    /** Nack code (e.g. `"479"`) when the server rejected the stanza; `None` for a plain ack. */
+    error?: string | null;
+}
+
+/** The type of spam flow indicating the source of the report. */
+export type SpamFlow = "GroupSpamBannerReport" | "GroupInfoReport" | "MessageMenu" | "ContactInfo" | "StatusReport";
+
+export interface StarUpdate {
+    /** The chat containing the starred or unstarred message. */
+    chat_jid: Jid;
+    /** The participant who sent the message. `Some` for group messages from others, `None` for self-authored or 1-on-1 messages (wire value `"0"`). */
+    participant_jid?: Jid | null;
+    message_id: string;
+    from_me: boolean;
+    timestamp: number;
+    action: StarAction;
+    from_full_sync: boolean;
+}
+
+/** Privacy setting sent in the `<meta>` node of the status stanza. Matches WhatsApp Web's `status_setting` attribute. */
+export type StatusPrivacySetting = "contacts" | "allowlist" | "denylist";
+
+export interface StreamError {
+    code: string;
+    raw?: any | null;
+}
+
+/** Trusted contact privacy token entry.  Matches WhatsApp Web's Chat.tcToken / tcTokenTimestamp / tcTokenSenderTimestamp. */
+export interface TcTokenEntry {
+    /** Raw token bytes received from the server. */
+    token: Uint8Array;
+    /** Unix timestamp (seconds) when the token was received. */
+    token_timestamp: number | string;
+    /** Unix timestamp (seconds) when we last issued our token to this contact. */
+    sender_timestamp?: number | string | null;
+}
+
+/** Wire codes: 101=SentToTooManyPeople, 102=BlockedByUsers, 103=CreatedTooManyGroups, 104=SentTooManySameMessage, 106=BroadcastList */
+export type TempBanReason = number;
+
+export interface TemporaryBan {
+    code: TempBanReason;
+    /** How long the ban lasts — the wire's `expire` is a duration in seconds, not a deadline (WA Web renders it as "You'll be able to use WhatsApp again in {duration}").  Dispatched only when the server sent an `expire` that fits a `Duration`; a ban stanza missing `code`/`expire`, or carrying one that does not, surfaces as [`Event::ConnectFailure`] instead, the way WA Web rejects it rather than inventing a zero. */
+    expire: number;
+    /** The server's `message` attribute, when present. */
+    message?: string | null;
+    /** Support/appeal link the official UI opens for the ban. */
+    url?: string | null;
+    /** The whole `<failure>` stanza. */
+    raw?: any | null;
+}
+
+export type UnavailableType = "unknown" | "view_once" | "hosted" | "bot";
+
+export interface UndecryptableMessage {
+    info: MessageInfo;
+    is_unavailable: boolean;
+    unavailable_type: UnavailableType;
+    decrypt_fail_mode: DecryptFailMode;
+}
+
+export interface UserAboutUpdate {
+    /** The contact whose about text changed. */
+    jid: Jid;
+    status: string;
+    timestamp: number;
+}
+
+/** A contact/group/newsletter's status updates were muted/unmuted on a linked device. */
+export interface UserStatusMuteUpdate {
+    /** The entity whose status was (un)muted. */
+    jid: Jid;
+    /** `true` = status muted, `false` = unmuted. */
+    muted: boolean;
+    timestamp: number;
+    action: UserStatusMuteAction;
+    from_full_sync: boolean;
+}
+
+/** Addressing mode used by the contact subprotocol. */
+export type UsyncAddressingMode = "pn" | "lid";
+
+export interface UsyncBotCommand {
+    name: string;
+    description: string;
+}
+
+export type UsyncBotProfessionalType = "unknown" | "yes" | "no" | string;
+
+export interface UsyncBotProfileResult {
+    name: string;
+    attributes: string;
+    description: string;
+    category: string;
+    is_default: boolean;
+    prompts: UsyncBotPrompt[];
+    persona_id: string;
+    commands: UsyncBotCommand[];
+    commands_description: string;
+    is_meta_created?: boolean | null;
+    creator_name?: string | null;
+    creator_profile_url?: string | null;
+    posing_as_professional?: UsyncBotProfessionalType | null;
+}
+
+export interface UsyncBotPrompt {
+    emoji: string;
+    text: string;
+}
+
+export interface UsyncBusinessResult {
+    verified_name?: VerifiedName | null;
+}
+
+export interface UsyncContactResult {
+    contact_type: string;
+    username?: string | null;
+    content?: string | null;
+}
+
+/** Usync context. */
+export type UsyncContext = "interactive" | "background" | "message" | "voip";
+
+export interface UsyncDeviceListResult {
+    hash?: string | null;
+    devices: UsyncDeviceResult[];
+}
+
+export interface UsyncDeviceResult {
+    id: number;
+    key_index?: number | null;
+    is_hosted: boolean;
+}
+
+/** Per-user cache hints carried by the devices v2 subprotocol. */
+export interface UsyncDeviceSyncHint {
+    /** Cached device-list hash, if known. */
+    device_hash?: string | null;
+    /** Timestamp associated with the cached hash. */
+    timestamp?: number | string | null;
+    /** Expected timestamp used to detect stale key-index state. */
+    expected_timestamp?: number | string | null;
+}
+
+export interface UsyncDevicesResult {
+    device_list?: UsyncDeviceListResult | null;
+    key_index?: UsyncKeyIndexResult | null;
+}
+
+export interface UsyncDisappearingModeResult {
+    duration_seconds: number;
+    setting_timestamp: number | string;
+    ephemerality_disabled: boolean;
+}
+
+/** Feature names accepted by the USync feature protocol. */
+export type UsyncFeature = "document" | "encrypt" | "encrypt_blist" | "encrypt_contact" | "encrypt_group_gen2" | "encrypt_image" | "encrypt_location" | "encrypt_url" | "encrypt_v2" | "voip" | "multi_agent";
+
+export interface UsyncFeatureResult {
+    feature: UsyncFeature;
+    value: string;
+}
+
+export interface UsyncKeyIndexResult {
+    timestamp: number | string;
+    signed_key_index_bytes?: Uint8Array | null;
+    expected_timestamp?: number | string | null;
+}
+
+/** Usync mode. */
+export type UsyncMode = "query" | "full" | "delta";
+
+/** A protocol value or its per-user error. Errors are boxed because they are rare and contain owned strings; this keeps every successful result variant from inheriting their size. */
+export type UsyncOutcome<T> =
+| { type: "value"; data: T }
+| { type: "error"; data: UsyncSubprotocolError };
+
+/** A known, typed USync subprotocol request. */
+export type UsyncProtocol =
+| { type: "contact"; data: { addressing_mode: UsyncAddressingMode } }
+| { type: "devices" }
+| { type: "status" }
+| { type: "text_status" }
+| { type: "disappearing_mode" }
+| { type: "business" }
+| { type: "picture" }
+| { type: "lid" }
+| { type: "username" }
+| { type: "bot" }
+| { type: "feature"; data: UsyncFeature[] };
+
+/** Known USync protocol tags from the captured WhatsApp Web client. */
+export type UsyncProtocolKind = "feature" | "devices" | "contact" | "picture" | "status" | "business" | "disappearing_mode" | "lid" | "bot" | "username" | "text_status";
+
+/** Sparse per-user result. Large, uncommon payloads are boxed so their layout does not inflate every status/contact/device item in large sync responses. */
+export type UsyncProtocolResult =
+| { type: "contact"; data: UsyncOutcome<UsyncContactResult> }
+| { type: "devices"; data: UsyncOutcome<UsyncDevicesResult> }
+| { type: "status"; data: UsyncOutcome<UsyncStatusResult> }
+| { type: "text_status"; data: UsyncOutcome<UsyncTextStatusResult> }
+| { type: "disappearing_mode"; data: UsyncOutcome<UsyncDisappearingModeResult> }
+| { type: "business"; data: UsyncOutcome<UsyncBusinessResult> }
+| { type: "picture"; data: UsyncOutcome<number | string> }
+| { type: "lid"; data: UsyncOutcome<Jid | null> }
+| { type: "username"; data: UsyncOutcome<string | null> }
+| { type: "bot"; data: UsyncOutcome<UsyncBotProfileResult> }
+| { type: "feature"; data: UsyncOutcome<UsyncFeatureResult[]> };
+
+/** Result-level state for a single protocol. */
+export interface UsyncProtocolState {
+    protocol: UsyncProtocolKind;
+    refresh_seconds?: number | null;
+    error?: UsyncSubprotocolError | null;
+}
+
+/** A complete typed USync query, validated before it reaches the network.  Deserialization always delegates to [`Self::new`], so a serialized input cannot bypass protocol uniqueness or per-user validation. */
+export interface UsyncQuery {
+    mode: UsyncMode;
+    context: UsyncContext;
+    protocols: UsyncProtocol[];
+    users: UsyncUser[];
+}
+
+/** Full neutral response from a typed USync query.  Its serialization walks this model by reference; no projection tree is constructed by the core. */
+export interface UsyncResponse {
+    protocol_states: UsyncProtocolState[];
+    users: UsyncUserResult[];
+}
+
+/** About/status payload. WhatsApp Web consumes only `status`, while the optional wire timestamp is retained for callers that need a lossless projection of responses carrying `t`. */
+export interface UsyncStatusResult {
+    status?: string | null;
+    timestamp?: number | string | null;
+}
+
+export interface UsyncSubprotocolError {
+    code?: number | null;
+    text?: string | null;
+    backoff?: number | null;
+}
+
+export interface UsyncTextStatusResult {
+    text?: string | null;
+    emoji?: string | null;
+    ephemeral_duration_seconds?: number | null;
+    last_update_time?: string | null;
+}
+
+/** A USync user input.  Constructors establish an identity and protocol-specific additions use explicit builder methods. Deserialization applies the same phone and JID normalization as those constructors; all invariants are validated when the user becomes part of [`UsyncQuery::new`]. */
+export interface UsyncUser {
+    id?: Jid | null;
+    pn_jid?: Jid | null;
+    phone?: string | null;
+    known_lid?: Jid | null;
+    device_sync?: UsyncDeviceSyncHint | null;
+    persona_id?: string | null;
+    username?: string | null;
+    username_pin?: string | null;
+    contact_type?: string | null;
+    tc_token?: Uint8Array | null;
+}
+
+/** Per-user response. `id` is optional because contact-only results without a JID are accepted by WhatsApp Web. */
+export interface UsyncUserResult {
+    id?: Jid | null;
+    pn_jid?: Jid | null;
+    protocols: UsyncProtocolResult[];
+}
+
+/** Verified name certificate information. */
+export interface VerifiedName {
+    name?: string | null;
+    serial?: string | null;
+    issuer?: string | null;
+    certificate?: Uint8Array | null;
+}
+
+/** In-call `<video state=N>` handshake states (audio→video upgrade, video→audio downgrade). Values verified against WA Web captures relayed by the mock server; unknown future states land in `Unknown` so a new server value degrades to an observable no-op instead of a parse failure. Wire codes: 0=Disabled, 1=Enabled, 2=Paused, 3=UpgradeRequest, 4=UpgradeAccept, 5=UpgradeReject, 6=Stopped, 7=UpgradeRejectByTimeout, 8=UpgradeCancel, 9=UpgradeCancelByTimeout, 10=UnknownPeer, 11=UpgradeRequestV2, 20=Error */
+export type VideoState = number;
+
+/** Authoritative waiting-room state for a call-link call. */
+export interface WaitingRoom {
+    call_id: string;
+    call_creator: Jid;
+    link_token: string;
+    media: CallLinkMedia;
+    enabled: boolean;
+    is_admin: boolean;
+    transaction_id?: number | null;
+    users: WaitingRoomUser[];
+}
+
+/** One user in a waiting-room snapshot. */
+export interface WaitingRoomUser {
+    jid: Jid;
+    pn?: Jid | null;
+    state: string;
+}
+
+
+
+export function getWasmAllocationSnapshot(): WasmAllocationSnapshot;
+
+
+
+export interface ILogger {
+    level: string;
+    trace(obj: object, msg?: string): void;
+    debug(obj: object, msg?: string): void;
+    info(obj: object, msg?: string): void;
+    warn(obj: object, msg?: string): void;
+    error(obj: object, msg?: string): void;
+}
+
+
+
+export interface WhatsAppClientConfig {
+    transport: JsTransportCallbacks;
+    httpClient: JsHttpClientConfig;
+    onEvent?: WhatsAppEventHandler;
+}
+
+/**
+ * Typed event sink. Message and history-sync events cross the boundary as
+ * protobuf wire bytes only: the host decodes them with its own codec, so the
+ * bridge never materializes an intermediate reflected JS tree (and never
+ * compiles the Rust->JS serializers for those proto graphs). A handler that
+ * omits `onMessageBatch`/`onHistorySyncBatch` has those events dropped with an
+ * error log; every other event kind continues through `onEvent`.
+ */
+export interface WhatsAppEventCallbacks {
+    onEvent(event: WhatsAppEvent): void;
+    /**
+     * Protobuf-wire message path. The bridge packs a bounded ordered group of
+     * messages — payloads and metadata alike — into one flat buffer. Decode it
+     * with `decodeMessageWireBatch`.
+     */
+    onMessageBatch(batch: MessageWireBatch): void;
+    /**
+     * Optional host-interest filter for conversation records. When present, the
+     * bridge still walks every history payload and emits its final metadata, but
+     * materializes conversation wire bytes only for the listed numeric sync
+     * types. Omit it for the backward-compatible "all types" behavior.
+     */
+    historySyncConversationTypes?: readonly number[];
+    /**
+     * Protobuf-wire history-sync path. Conversation entries cross as wire bytes
+     * and the non-conversation remainder (pushnames, mappings, settings, ...)
+     * crosses as one encoded `proto.HistorySync` payload in `remainderData`.
+     * Return the number of malformed entries skipped by the host, if any.
+     */
+    onHistorySyncBatch(batch: HistorySyncWireBatch): number | void;
+    /**
+     * Optional packed receipt path: adjacent `receipt` events coalesce into one
+     * flat buffer (decode with `decodeReceiptWireBatch`) instead of one
+     * reflected object per event. Without it, receipts use `onEvent`.
+     * Decode the batch fully before calling back into the client: the reader
+     * walks the buffer in order and shares cached JID objects across events.
+     */
+    onReceiptBatch?(batch: ReceiptWireBatch): void;
+    /**
+     * Optional packed server-ack path, analogous to `onReceiptBatch`; decode
+     * with `decodeServerAckWireBatch`. Without it, acks use `onEvent`.
+     */
+    onServerAckBatch?(batch: ServerAckWireBatch): void;
+}
+
+/**
+ * A packed batch is one flat buffer: header, records and string bytes. Decode it
+ * with the matching codec (`decodeMessageWireBatch`, `decodeReceiptWireBatch`,
+ * `decodeServerAckWireBatch`), which reads views over the buffer instead of
+ * copying. The bare typed array crosses rather than a wrapper object: one
+ * message produces three batches, so an object per batch is three constructions
+ * and three property writes of pure overhead.
+ */
+export type MessageWireBatch = Uint8Array;
+export type ReceiptWireBatch = Uint8Array;
+export type ServerAckWireBatch = Uint8Array;
+
+export type HistorySyncWireBatch = {
+    /** Concatenated Conversation protobuf payloads for this bounded batch. */
+    conversationData: Uint8Array;
+    /** Start offsets into conversationData, followed by its final byte length. */
+    conversationOffsets: Uint32Array;
+    /**
+     * Encoded `proto.HistorySync` carrying every non-conversation field. Present
+     * only on the final batch of a chunk.
+     */
+    remainderData?: Uint8Array;
+    syncType: number;
+    chunkOrder?: number;
+    progress?: number;
+    peerDataRequestSessionId?: string;
+    batchIndex: number;
+    isFinalBatch: boolean;
+};
+
+/**
+ * Plain functions remain supported for control-plane events (pairing, QR,
+ * connection lifecycle); message and history-sync delivery requires the
+ * callback-object form above.
+ */
+export type WhatsAppEventHandler =
+| ((event: WhatsAppEvent) => void)
+| WhatsAppEventCallbacks;
+
+/**
+ * JS storage callbacks for the persistent backend.
+ *
+ * The boundary is a two-level namespaced key/value store: `store` is one of the
+ * fixed STORE_* namespaces (e.g. "session", "msg_secret", "lid_mapping") and
+ * `key` is an opaque, namespace-scoped id; values are raw bytes.
+ *
+ * Only `get`/`set`/`delete` are MANDATORY — a 3-method store keeps working
+ * exactly as before. The remaining methods are OPTIONAL performance/structural
+ * primitives the core feature-detects (by handle presence) and uses when the
+ * host provides them:
+ *   - `setMany`/`deleteMany` collapse N per-key FFI crossings into one (this is
+ *     what turns a ~20k-secret history-sync write from 20k awaits into a single
+ *     batched call).
+ *   - `listKeys`/`listEntries` let the core enumerate a namespace directly,
+ *     which lets it DROP its hand-maintained meta-index lists (msg_secret_keys,
+ *     tc_token_jids, …). A host that cannot enumerate a category (e.g. an
+ *     id-addressed external key store) simply omits them; the core then keeps its
+ *     self-maintained index for that backend.
+ *   - `deletePrefix` accelerates unconditional bulk clears.
+ *
+ * `capabilities` is read ONCE at init. Omit it (or a field) and the core treats
+ * the corresponding primitive as absent. A capability declared `true` MUST have
+ * its method(s) present and working.
+ */
+export interface JsStoreCallbacks {
+    /** Read one value by (store, key). Null/undefined if absent. MANDATORY. */
+    get(store: string, key: string): Promise<Uint8Array | null>;
+    /** Write one value by (store, key). MANDATORY. */
+    set(store: string, key: string, value: Uint8Array): Promise<void>;
+    /** Delete one key. No-op if absent. MANDATORY. */
+    delete(store: string, key: string): Promise<void>;
+
+    /**
+     * Write many [key, value] pairs into ONE store in a single call. Entries are
+     * tuples (so keys may contain any character). Best-effort: if the medium has
+     * no cross-key atomicity (file-per-key) it MUST still apply every entry and
+     * fail-fast on error so the core can retry (writes are idempotent by key).
+     * Empty array is a valid no-op.
+     */
+    setMany?(store: string, entries: [key: string, value: Uint8Array][]): Promise<void>;
+
+    /** Read many keys from ONE store; one entry per FOUND key, any order. */
+    getMany?(store: string, keys: string[]): Promise<[key: string, value: Uint8Array][]>;
+
+    /** Delete many keys from ONE store in a single call. Missing keys ignored. */
+    deleteMany?(store: string, keys: string[]): Promise<void>;
+
+    /** Enumerate live keys in `store` (optionally prefix-filtered). Unordered. */
+    listKeys?(store: string, prefix?: string): Promise<string[]>;
+
+    /**
+     * Like listKeys but returns [key, value] pairs, so the core can inspect the
+     * embedded timestamp prefix for delete-expired sweeps without N follow-up
+     * gets. If absent but listKeys exists, the core falls back to listKeys+getMany.
+     */
+    listEntries?(store: string, prefix?: string): Promise<[key: string, value: Uint8Array][]>;
+
+    /** Delete every key in `store` starting with `prefix`. Returns count removed. */
+    deletePrefix?(store: string, prefix: string): Promise<number>;
+
+    /** Static capability declaration, read once at init. Omitted => all false. */
+    capabilities?: {
+        /** setMany/getMany/deleteMany are implemented. */
+        batch?: boolean;
+        /** listKeys/listEntries reliably enumerate a namespace. */
+        enumerate?: boolean;
+        /** deletePrefix is implemented. */
+        prefixDelete?: boolean;
+    };
+
+    /** Optional durability barrier (flush pending writes). */
+    flush?(): Promise<void>;
+}
+
+/**
+ * Initialize the WASM engine. Call once before creating clients.
+ * @param logger Optional pino-compatible logger.
+ * @param crypto Optional native crypto callbacks — when provided, AES/HMAC
+ *               primitives delegate to the host (e.g. `node:crypto`). Falls
+ *               back to the Rust-soft implementation if omitted.
+ */
+export function initWasmEngine(logger?: any, crypto?: JsCryptoCallbacks): void;
+
+/**
+ * Create a full WhatsApp client running in WASM.
+ *
+ * @param transport_config WebSocket transport callbacks (connect/send/disconnect)
+ * @param http_config HTTP client callbacks (execute via fetch)
+ * @param on_event Optional typed event sink — receives WhatsApp events in order
+ * @param store Optional JS storage callbacks — if provided, enables persistent storage
+ * @param cache_config Optional cache TTL/capacity and custom store overrides
+ * @param version Optional [major, minor, patch] WhatsApp Web version override
+ * @param wanted_pre_key_count Optional pre-key upload batch size (default 812);
+ *   clamped to the protocol-safe range at upload time. Smaller batches reduce
+ *   memory pressure on embedded/WASM hosts.
+ */
+export function createWhatsAppClient(
+transport_config: JsTransportCallbacks,
+http_config: JsHttpClientConfig,
+on_event?: WhatsAppEventHandler | null,
+store?: JsStoreCallbacks | null,
+cache_config?: CacheConfig | null,
+version?: readonly [number, number, number] | null,
+wanted_pre_key_count?: number | null,
+): Promise<WasmWhatsAppClient>;
+
+/** Cache entry configuration. */
+export interface CacheEntryConfig {
+    ttlSecs?: number;
+    capacity?: number;
+    store?: JsCacheStore;
+}
+
+/** Custom cache backend. */
+export interface JsCacheStore {
+    get(namespace: string, key: string): Promise<Uint8Array | null>;
+    set(namespace: string, key: string, value: Uint8Array, ttlSecs?: number): Promise<void>;
+    delete(namespace: string, key: string): Promise<void>;
+    clear(namespace: string): Promise<void>;
+}
+
+/** Cache configuration — all fields optional. */
+export interface CacheConfig {
+    store?: JsCacheStore;
+    group?: CacheEntryConfig;
+    device?: CacheEntryConfig;
+    deviceRegistry?: CacheEntryConfig;
+    lidPn?: CacheEntryConfig;
+    retriedGroupMessages?: CacheEntryConfig;
+    recentMessages?: CacheEntryConfig;
+    messageRetry?: CacheEntryConfig;
+}
+
+// Augment WasmWhatsAppClient with methods that need skip_typescript
+// (Record returns can't be expressed by wasm-bindgen)
+interface WasmWhatsAppClient {
+    /** Fetch all groups the user is participating in. */
+    groupFetchAllParticipating(): Promise<Record<string, GroupMetadataResult>>;
+    /** Fetch all parent groups the user is participating in. */
+    communityFetchAllParticipating(): Promise<Record<string, GroupMetadataResult>>;
+    /** Fetch user info for one or more JIDs. */
+    fetchUserInfo(jids: string[]): Promise<Record<string, UserInfoResult>>;
+}
+
+
+/**
+ * A message key for `readMessages`.
+ */
+export interface ReadMessageKey {
+    remoteJid: string;
+    id: string;
+    participant?: string;
+}
+
+/**
+ * A participant change result from `groupParticipantsUpdate`.
+ */
+export interface ParticipantChangeResult {
+    jid: string;
+    status?: string;
+    error?: string;
+    phoneNumber?: string;
+    username?: string;
+    addRequest?: ParticipantAddRequestResult;
+}
+
+/**
+ * A single entry from `fetchBlocklist`.
+ */
+export interface BlocklistEntryResult {
+    jid: string;
+    timestamp?: number;
+}
+
+/**
+ * A single entry from `fetchUserInfo`.
+ */
+export interface UserInfoResult {
+    jid: string;
+    lid?: string;
+    status?: string;
+    pictureId?: string;
+    isBusiness: boolean;
+    /**
+     * Verified business name from the usync `<business><verified_name>` cert, if any.
+     */
+    verifiedName?: string;
+    /**
+     * Device IDs from the usync `<devices>` sublist the same query returns. Empty when
+     * the server returned no device list.
+     */
+    devices: number[];
+}
+
+/**
+ * A single media host from `getMediaConn`.
+ */
+export interface MediaHost {
+    hostname: string;
+}
+
+/**
+ * A subgroup returned by a parent-group metadata query.
+ */
+export interface CommunitySubgroupResult {
+    id: string;
+    subject: string;
+    participantCount?: number;
+    creation?: number;
+    owner?: string;
+    isDefaultSubGroup: boolean;
+    isGeneralChat: boolean;
+}
+
+/**
+ * Allocation churn attributed by whatsapp-rust\'s own `AllocMeter` to tasks
+ * spawned for this client. Available in diagnostics builds only.
+ */
+export interface CoreAllocationSnapshotResult {
+    enabled: boolean;
+    allocatedBytes: number;
+    freedBytes: number;
+    allocations: number;
+    netBytes: number;
+}
+
+/**
+ * Allocation scope active when an allocator call committed more WASM pages.
+ * These are bridge boundaries, not WhatsApp protocol operation names.
+ */
+export type AllocationScope = "other" | "coreTask" | "historyDecode" | "historySerialize" | "historyEnvelope" | "historyCallback" | "diagnostics";
+
+/**
+ * Allocation totals for one tracing callsite emitted by whatsapp-rust itself.
+ * Names and source locations come from `tracing::Metadata`; the bridge does
+ * not maintain a parallel list of core operations.
+ */
+export interface CoreSpanAllocationSnapshot {
+    name: string;
+    target: string;
+    sourceFile: string | undefined;
+    sourceLine: number | undefined;
+    allocatedBytes: number;
+    allocations: number;
+    largestAllocationBytes: number;
+    linearGrowthBytes: number;
+    linearGrowthEvents: number;
+}
+
+/**
+ * Block/unblock action.
+ */
+export type BlockAction = "block" | "unblock";
+
+/**
+ * Business category info.
+ */
+export interface BusinessCategoryResult {
+    id: string;
+    name: string;
+}
+
+/**
+ * Business hours config for a day.
+ */
+export interface BusinessHoursConfigResult {
+    dayOfWeek: string;
+    mode: string;
+    openTime?: number;
+    closeTime?: number;
+}
+
+/**
+ * Business hours.
+ */
+export interface BusinessHoursResult {
+    timezone?: string;
+    businessConfig?: BusinessHoursConfigResult[];
+}
+
+/**
+ * Chat state (typing indicator).
+ */
+export type ChatState = "composing" | "recording" | "paused";
+
+/**
+ * Counts produced while moving pairwise sessions between identifier namespaces.
+ */
+export interface SignalSessionMigrationResult {
+    migrated: number;
+    skipped: number;
+    total: number;
+}
+
+/**
+ * Disappearing-message settings returned by the group `<ephemeral>` node.
+ *
+ * The outer `Option` on `GroupMetadataResult::ephemeral` preserves the
+ * distinction between an absent node and a present node whose values are
+ * zero or omitted.
+ */
+export interface GroupEphemeralSettingsResult {
+    expiration?: number;
+    trigger?: number;
+}
+
+/**
+ * Enabled features in this build.
+ * Use this to check feature availability at runtime before calling feature-gated functions.
+ */
+export interface EnabledFeatures {
+    /**
+     * Audio processing support (waveform generation, duration detection)
+     */
+    audio: boolean;
+    /**
+     * Image processing support (thumbnails, profile pictures, format conversion)
+     */
+    image: boolean;
+    /**
+     * Sticker metadata support (WebP EXIF for WhatsApp stickers)
+     */
+    sticker: boolean;
+}
+
+/**
+ * Group join request action.
+ */
+export type GroupRequestAction = "approve" | "reject";
+
+/**
+ * Group member add mode.
+ */
+export type MemberAddMode = "admin_add" | "all_member_add";
+
+/**
+ * Group participant action.
+ */
+export type GroupParticipantAction = "add" | "remove" | "promote" | "demote" | "modify";
+
+/**
+ * Group participant info as returned from `getGroupMetadata` / cached group
+ * state. Distinct from `wacore::stanza::groups::GroupParticipantInfo` (the
+ * event-time variant that carries `Jid` objects on the wire); naming it
+ * separately avoids the TypeScript collision that forced consumers to cast.
+ */
+export interface GroupMetadataParticipant {
+    jid: string;
+    phoneNumber?: string;
+    /**
+     * LID counterpart when `jid` is a phone-number JID.
+     */
+    lid?: string;
+    /**
+     * Meta username carried by the participant node, when present.
+     */
+    username?: string;
+    /**
+     * Protocol role (`member`, `admin`, or `superadmin`).
+     */
+    participantType: string;
+    isAdmin: boolean;
+    isSuperAdmin: boolean;
+}
+
+/**
+ * Group setting type.
+ */
+export type GroupSetting = "locked" | "announce" | "membership_approval";
+
+/**
+ * Inputs required to establish one outgoing pairwise session.
+ */
+export interface SignalSessionBundleInput {
+    registrationId: number;
+    identityKey: Uint8Array;
+    signedPreKey: SignalSignedPreKeyInput;
+    preKey?: SignalPreKeyInput;
+}
+
+/**
+ * Invite fallback returned for a participant that could not be added directly.
+ */
+export interface ParticipantAddRequestResult {
+    code: string;
+    expiration: number;
+}
+
+/**
+ * Key of an existing message targeted by `sendReaction` / `sendCommentBytes`.
+ * The chat JID comes from the method\'s `jid` argument; `participant` is the
+ * original sender (required for group/status targets).
+ */
+export interface TargetMessageKey {
+    id: string;
+    fromMe?: boolean;
+    participant?: string;
+}
+
+/**
+ * Media type for upload/download operations.
+ */
+export type MediaType = "image" | "video" | "audio" | "document" | "sticker" | "thumbnail-link" | "md-msg-hist" | "md-app-state" | "product-catalog-image";
+
+/**
+ * Mirrors `device_props.HistorySyncConfig`. Only fields a consumer would
+ * realistically tune are exposed individually; partial overrides merge into
+ * `wacore::store::default_history_sync_config()` so callers don\'t accidentally
+ * drop the WA-Web-aligned support_* claims by setting just one field.
+ */
+export interface DeviceHistorySyncConfig {
+    fullSyncDaysLimit?: number;
+    fullSyncSizeMbLimit?: number;
+    storageQuotaMb?: number;
+    recentSyncDaysLimit?: number;
+    supportCallLogHistory?: boolean;
+    supportGroupHistory?: boolean;
+    onDemandReady?: boolean;
+    thumbnailSyncDaysLimit?: number;
+    initialSyncMaxMessagesPerChat?: number;
+}
+
+/**
+ * Mirrors `device_props.PlatformType`. The display value the phone shows in
+ * \"Linked Devices\" — and the type WhatsApp\'s server uses to decide whether
+ * features like view-once are deliverable as payload or as `absent` stub.
+ * Variant names render as `SCREAMING_SNAKE_CASE` in TS to match the proto
+ * enum identifiers callers see in WhatsApp documentation / wire dumps.
+ */
+export type DevicePlatformType = "UNKNOWN" | "CHROME" | "FIREFOX" | "IE" | "OPERA" | "SAFARI" | "EDGE" | "DESKTOP" | "IPAD" | "ANDROID_TABLET" | "OHANA" | "ALOHA" | "CATALINA" | "TCL_TV" | "IOS_PHONE" | "IOS_CATALYST" | "ANDROID_PHONE" | "ANDROID_AMBIGUOUS" | "WEAR_OS" | "AR_WRIST" | "AR_DEVICE" | "UWP" | "VR" | "CLOUD_API" | "SMARTGLASSES";
+
+/**
+ * Neutral controls for retransmitting an existing message to one device.
+ *
+ * The encoded message remains a separate byte slice so this small control
+ * object never base64-encodes or copies the protobuf payload.
+ */
+export interface MessageRetransmissionInput {
+    requesterJid: string;
+    messageId: string;
+    retryCount: number;
+    recipientJid?: string;
+    refreshGroupMetadata: boolean;
+}
+
+/**
+ * One allocator call that exhausted the current linear-memory capacity.
+ * History counters provide a deterministic progress marker without sampling
+ * wall-clock time or reconstructing any core behavior in the bridge.
+ */
+export interface AllocationEventSnapshot {
+    sequence: number;
+    allocationIndex: number;
+    scope: AllocationScope;
+    coreSpan: string | undefined;
+    allocationBytes: number;
+    linearGrowthBytes: number;
+    linearBytesAfter: number;
+    heapLiveBytesAfter: number;
+    historyEvents: number;
+    historyConversations: number;
+}
+
+/**
+ * One failed parent/subgroup relationship mutation.
+ */
+export interface CommunityLinkFailureResult {
+    jid: string;
+    error: number;
+}
+
+/**
+ * One linked-identifier to phone-number mapping supplied by the host.
+ */
+export interface LidPnMappingInput {
+    lid: string;
+    pn: string;
+}
+
+/**
+ * Optional Noise-payload overrides applied on top of every preset.
+ * Leaving any field `None` preserves wacore\'s default, which matches
+ * WA Web (notably `phoneId` stays unset on the wire).
+ */
+export interface ClientProfileOverrides {
+    phoneId?: string | undefined;
+    localeLanguage?: string | undefined;
+    localeCountry?: string | undefined;
+    passiveLogin?: boolean | undefined;
+}
+
+/**
+ * Picture type for profile picture URL.
+ */
+export type PictureType = "preview" | "image";
+
+/**
+ * Presence status.
+ */
+export type PresenceStatus = "available" | "unavailable";
+
+/**
+ * Public error shape that crosses the WASM→JS boundary.
+ *
+ * Variants are intentionally flat — no `#[from]` on enum variants, no
+ * `#[serde(flatten)]`. Translation from the core\'s typed errors happens in
+ * `From` impls below by walking the source chain. This keeps the JS object
+ * shape predictable and the codegen / `Tsify` output simple.
+ */
+export type BridgeError = { kind: "server"; serverCode: number; serverText: string } | { kind: "timeout" } | { kind: "not-connected" } | { kind: "disconnected"; reason: string } | { kind: "invalid-argument"; field: string; reason: string } | { kind: "protocol-violation"; reason: string } | { kind: "crypto"; operation: string } | { kind: "storage"; operation: string } | { kind: "internal"; message: string };
+
+/**
+ * Public portion of one pre-key in a supplied pairwise session bundle.
+ */
+export interface SignalPreKeyInput {
+    keyId: number;
+    publicKey: Uint8Array;
+}
+
+/**
+ * Read-only information from a currently open pairwise session.
+ */
+export interface SignalSessionInfoResult {
+    baseKey: Uint8Array;
+    registrationId: number;
+}
+
+/**
+ * Result from `createPoll`.
+ */
+export interface CreatePollResult {
+    messageId: string;
+    messageSecret: Uint8Array;
+}
+
+/**
+ * Result from `encryptMediaStream`.
+ */
+export interface EncryptMediaResult {
+    mediaKey: Uint8Array;
+    fileSha256: Uint8Array;
+    fileEncSha256: Uint8Array;
+    fileLength: number;
+}
+
+/**
+ * Result from `fetchStatus`.
+ */
+export interface FetchStatusResult {
+    jid: string;
+    status?: string;
+}
+
+/**
+ * Result from `getBusinessProfile`.
+ */
+export interface BusinessProfileResult {
+    wid?: string;
+    description: string;
+    email?: string;
+    website: string[];
+    categories: BusinessCategoryResult[];
+    address?: string;
+    businessHours: BusinessHoursResult;
+}
+
+/**
+ * Result from `getGroupMetadata`.
+ */
+export interface GroupMetadataResult {
+    id: string;
+    subject: string;
+    notify?: string;
+    participants: GroupMetadataParticipant[];
+    addressingMode: string;
+    creator?: string;
+    creatorPn?: string;
+    creatorUsername?: string;
+    creatorCountryCode?: string;
+    creationTime?: number;
+    subjectTime?: number;
+    subjectOwner?: string;
+    subjectOwnerPn?: string;
+    subjectOwnerUsername?: string;
+    description?: string;
+    descriptionId?: string;
+    descriptionOwner?: string;
+    descriptionOwnerPn?: string;
+    descriptionOwnerUsername?: string;
+    descriptionTime?: number;
+    isLocked: boolean;
+    isAnnouncement: boolean;
+    ephemeral?: GroupEphemeralSettingsResult;
+    membershipApproval: boolean;
+    memberAddMode?: string;
+    memberLinkMode?: string;
+    size?: number;
+    isParentGroup: boolean;
+    parentGroupJid?: string;
+    isDefaultSubGroup: boolean;
+    isGeneralChat: boolean;
+    allowNonAdminSubGroupCreation: boolean;
+    noFrequentlyForwarded: boolean;
+    memberShareHistoryMode?: string;
+    growthLocked?: GroupGrowthLockInfoResult;
+    isSuspended: boolean;
+    allowAdminReports: boolean;
+    isHiddenGroup: boolean;
+    isIncognito: boolean;
+    hasGroupHistory: boolean;
+    isLimitSharingEnabled: boolean;
+}
+
+/**
+ * Result from `getMediaConn`.
+ */
+export interface MediaConnResult {
+    auth: string;
+    ttl: number;
+    hosts: MediaHost[];
+}
+
+/**
+ * Result from `getMemoryDiagnostics`.
+ */
+export interface MemoryDiagnosticsResult {
+    groupCache: number;
+    groupCacheBytes: number;
+    deviceRegistryCache: number;
+    deviceRegistryCacheBytes: number;
+    senderKeyDeviceCache: number;
+    senderKeyDeviceCacheBytes: number;
+    groupDevicesMemo: number;
+    groupDevicesMemoBytes: number;
+    lidPnLidEntries: number;
+    lidPnLidBytes: number;
+    lidPnPnEntries: number;
+    lidPnPnBytes: number;
+    recentMessages: number;
+    recentMessagesBytes: number;
+    messageRetryCounts: number;
+    undecryptableDispatched: number;
+    pdoPendingRequests: number;
+    pdoRequested: number;
+    sessionLocks: number;
+    chatLanes: number;
+    groupDistributionLocks: number;
+    groupDistributionLockEvictions: number;
+    groupDistributionLockEvictionBlocks: number;
+    resendRateLimiterChats: number;
+    responseWaiters: number;
+    nodeWaiters: number;
+    pendingRetries: number;
+    presenceSubscriptions: number;
+    appStateKeyRequests: number;
+    appStateSyncing: number;
+    signalCacheSessions: number;
+    signalCacheSessionsBytes: number;
+    signalCacheIdentities: number;
+    signalCacheIdentitiesBytes: number;
+    signalCacheSenderKeys: number;
+    signalCacheSenderKeysBytes: number;
+    historySyncTasks: number;
+    historySyncPayloadBytes: number;
+    historySyncPeakTasks: number;
+    historySyncPeakPayloadBytes: number;
+    chatstateHandlers: number;
+    customEncHandlers: number;
+    clientEstimatedBytes: number;
+    storageMemoryBytes?: number;
+    storagePages?: number;
+    storageIoReadBytes?: number;
+    storageIoWriteBytes?: number;
+    transportReadBufferBytes?: number;
+    transportWriteBufferBytes?: number;
+    transportTlsStateBytes?: number;
+    httpPoolConnections?: number;
+    httpPoolBufferBytes?: number;
+    httpInflightBytes?: number;
+    resourceEstimatedBytes: number;
+}
+
+/**
+ * Result from `groupRequestParticipantsList`.
+ */
+export interface MembershipRequestResult {
+    jid: string;
+    requestTime?: number;
+}
+
+/**
+ * Result from `isOnWhatsApp`.
+ *
+ * Mirrors the core `IsOnWhatsAppResult` so callers get the LID/PN counterpart
+ * and business flag from the same usync round trip — no follow-up
+ * `fetchUserInfo` IQ needed for the common \"check + enrich\" flow.
+ */
+export interface IsOnWhatsAppResult {
+    jid: string;
+    isRegistered: boolean;
+    /**
+     * LID counterpart of `jid` when the input was a PN, populated from the
+     * usync `<lid>` attribute (or the local LID/PN cache).
+     */
+    lid?: string;
+    /**
+     * PN counterpart, set when the server responds with a LID as primary JID.
+     */
+    pnJid?: string;
+    isBusiness: boolean;
+    /**
+     * Verified business name from the usync `<business><verified_name>` cert, if any.
+     */
+    verifiedName?: string;
+}
+
+/**
+ * Result from `profilePictureUrl`.
+ */
+export interface ProfilePictureInfo {
+    id: string;
+    url: string;
+    directPath?: string;
+    hash?: string;
+}
+
+/**
+ * Result from `updateProfilePicture` or `removeProfilePicture`.
+ */
+export interface ProfilePictureResult {
+    id: string;
+}
+
+/**
+ * Result from `uploadMedia`.
+ */
+export interface UploadMediaResult {
+    url: string;
+    directPath: string;
+    mediaKey: Uint8Array;
+    fileSha256: Uint8Array;
+    fileEncSha256: Uint8Array;
+    fileLength: number;
+}
+
+/**
+ * Result from newsletter methods.
+ */
+export interface NewsletterMetadataResult {
+    jid: string;
+    name: string;
+    description?: string;
+    subscriberCount: number;
+    verification: string;
+    state: string;
+    pictureUrl?: string;
+    previewUrl?: string;
+    inviteCode?: string;
+    role?: string;
+    creationTime?: number;
+}
+
+/**
+ * Result of linking or unlinking subgroups.
+ */
+export interface CommunityLinkResult {
+    succeeded: string[];
+    failed: CommunityLinkFailureResult[];
+}
+
+/**
+ * Selects which `ClientProfile` preset to use for the noise-handshake
+ * `ClientPayload.UserAgent`. Independent of `DeviceProps`: `setDeviceProps`
+ * controls the \"Linked Devices\" display on the phone, this controls what
+ * the server sees in the noise layer.
+ *
+ * Use `{ preset: \'android\', osVersion: \'13\' }` to advertise
+ * `UserAgent.platform = ANDROID` with `web_info` omitted.
+ *
+ * Every variant flattens the [`ClientProfileOverrides`] fields, so the
+ * JS literal is flat (e.g. `{ preset: \'web\', phoneId: \'fixed-id\' }`).
+ */
+export type ClientProfileInput = ({ preset: "web" } & {} & ClientProfileOverrides) | ({ preset: "android" } & { osVersion: string } & ClientProfileOverrides) | ({ preset: "smbAndroid" } & { osVersion: string } & ClientProfileOverrides) | ({ preset: "ios" } & { osVersion: string } & ClientProfileOverrides) | ({ preset: "macos" } & { osVersion: string } & ClientProfileOverrides) | ({ preset: "windows" } & { osVersion: string } & ClientProfileOverrides);
+
+/**
+ * Server-managed group growth lock information.
+ */
+export interface GroupGrowthLockInfoResult {
+    lockType: string;
+    expiration: number;
+}
+
+/**
+ * Signed pre-key in a supplied pairwise session bundle.
+ */
+export interface SignalSignedPreKeyInput {
+    keyId: number;
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+}
+
+export interface AllocationBucketSnapshot {
+    allocatedBytes: number;
+    allocations: number;
+    largestAllocationBytes: number;
+    /**
+     * WASM pages committed by allocator calls executed in this scope.
+     */
+    linearGrowthBytes: number;
+    linearGrowthEvents: number;
+}
+
+export interface DeviceAppVersion {
+    primary?: number;
+    secondary?: number;
+    tertiary?: number;
+    quaternary?: number;
+}
+
+export interface DevicePropsInput {
+    os?: string;
+    platformType?: DevicePlatformType;
+    version?: DeviceAppVersion;
+    historySyncConfig?: DeviceHistorySyncConfig;
+}
+
+export interface HistorySyncAllocationSnapshot {
+    events: number;
+    compressedBytes: number;
+    decompressedBytes: number;
+    conversations: number;
+    batches: number;
+    skippedConversations: number;
+    largestCompressedBytes: number;
+    largestDecompressedBytes: number;
+    /**
+     * Compressed history events waiting in the bridge\'s ordered event queue.
+     */
+    queuedEvents: number;
+    queuedCompressedBytes: number;
+    peakQueuedEvents: number;
+    peakQueuedCompressedBytes: number;
+    /**
+     * Dequeued history events still being decoded or synchronously delivered.
+     */
+    activeEvents: number;
+    activeCompressedBytes: number;
+    peakActiveEvents: number;
+    peakActiveCompressedBytes: number;
+    /**
+     * Queue plus active bridge ownership. This attributes retention without
+     * guessing from allocator lifetime or duplicating core protocol logic.
+     */
+    retainedEvents: number;
+    retainedCompressedBytes: number;
+    peakRetainedEvents: number;
+    peakRetainedCompressedBytes: number;
+}
+
+export interface HkdfInfo {
+    salt?: Uint8Array | undefined;
+    info?: string | undefined;
+}
+
+export interface KeyPair {
+    pubKey: Uint8Array;
+    privKey: Uint8Array;
+}
+
+export interface LegacyIndexedSessionV1 {
+    indexKey: Uint8Array;
+    session: LegacySessionV1;
+}
+
+export interface LegacySessionChainKeyV1 {
+    counter: number;
+    key?: Uint8Array | undefined;
+}
+
+export interface LegacySessionChainV1 {
+    ratchetKey: Uint8Array;
+    role: number;
+    chainKey: LegacySessionChainKeyV1;
+    messageKeys: LegacySessionMessageKeyV1[];
+}
+
+export interface LegacySessionIndexV1 {
+    baseKey: Uint8Array;
+    baseKeyRole: number;
+    closedTimestamp: number;
+    usedAtMs: number;
+    createdAtMs: number;
+    remoteIdentityKey: Uint8Array;
+}
+
+export interface LegacySessionKeyPairV1 {
+    public: Uint8Array;
+    private: Uint8Array;
+}
+
+export interface LegacySessionLocalContext {
+    identityKey: Uint8Array;
+    registrationId: number;
+}
+
+export interface LegacySessionMessageKeyV1 {
+    index: number;
+    seed: Uint8Array;
+}
+
+export interface LegacySessionPendingPreKeyV1 {
+    preKeyId: number | undefined;
+    signedPreKeyId: number;
+    baseKey: Uint8Array;
+}
+
+export interface LegacySessionProjectionIssueV1 {
+    session: number;
+    chain: number | undefined;
+    field: LegacySessionUnrepresentableFieldV1;
+}
+
+export interface LegacySessionRatchetV1 {
+    keyPair: LegacySessionKeyPairV1;
+    lastRemoteEphemeralKey: Uint8Array;
+    /**
+     * v1 allows `-1` for a never-used sending chain; the core validates the
+     * `-1..=u32::MAX` range and owns the floor-to-zero translation.
+     */
+    previousCounter: number;
+    rootKey: Uint8Array;
+}
+
+export interface LegacySessionRecordV1 {
+    sessions: LegacyIndexedSessionV1[];
+}
+
+export interface LegacySessionV1 {
+    registrationId: number;
+    ratchet: LegacySessionRatchetV1;
+    index: LegacySessionIndexV1;
+    chains: LegacySessionChainV1[];
+    pendingPreKey: LegacySessionPendingPreKeyV1 | undefined;
+}
+
+export interface PendingKeyExchangeComponents {
+    sequence: number | undefined;
+    localBaseKey: Uint8Array | undefined;
+    localBaseKeyPrivate: Uint8Array | undefined;
+    localRatchetKey: Uint8Array | undefined;
+    localRatchetKeyPrivate: Uint8Array | undefined;
+    localIdentityKey: Uint8Array | undefined;
+    localIdentityKeyPrivate: Uint8Array | undefined;
+}
+
+export interface PendingPreKeyComponents {
+    preKeyId: number | undefined;
+    signedPreKeyId: number | undefined;
+    baseKey: Uint8Array | undefined;
+    kyberPreKeyId: number | undefined;
+    kyberCiphertext: Uint8Array | undefined;
+}
+
+export interface ReceiverSessionChainComponents {
+    senderRatchetKey: Uint8Array | undefined;
+    chainKey: SessionChainKeyComponents | undefined;
+    messageKeys: SessionMessageKeyComponents[];
+}
+
+export interface RequiredSessionChainKeyComponents {
+    index: number;
+    key: Uint8Array;
+}
+
+export interface SenderChainKeyComponents {
+    iteration: number;
+    seed: Uint8Array;
+}
+
+export interface SenderKeyRecordComponents {
+    states: SenderKeyStateComponents[];
+}
+
+export interface SenderKeyStateComponents {
+    keyId: number;
+    chainKey: SenderChainKeyComponents;
+    signingKey: SenderSigningKeyComponents;
+    messageKeys: SenderMessageKeyComponents[];
+}
+
+export interface SenderMessageKeyComponents {
+    iteration: number;
+    seed: Uint8Array;
+}
+
+export interface SenderSessionChainComponents {
+    senderRatchetKey: Uint8Array;
+    senderRatchetKeyPrivate: Uint8Array;
+    chainKey: RequiredSessionChainKeyComponents;
+    messageKeys: SessionMessageKeyComponents[];
+}
+
+export interface SenderSigningKeyComponents {
+    public: Uint8Array;
+    private: Uint8Array | undefined;
+}
+
+export interface SessionChainKeyComponents {
+    index: number | undefined;
+    key: Uint8Array | undefined;
+}
+
+export interface SessionComponents {
+    sessionVersion: number | undefined;
+    localIdentityPublic: Uint8Array | undefined;
+    remoteIdentityPublic: Uint8Array | undefined;
+    rootKey: Uint8Array | undefined;
+    previousCounter: number | undefined;
+    senderChain: SenderSessionChainComponents | undefined;
+    receiverChains: ReceiverSessionChainComponents[];
+    pendingKeyExchange: PendingKeyExchangeComponents | undefined;
+    pendingPreKey: PendingPreKeyComponents | undefined;
+    remoteRegistrationId: number | undefined;
+    localRegistrationId: number | undefined;
+    needsRefresh: boolean | undefined;
+    aliceBaseKey: Uint8Array | undefined;
+}
+
+export interface SessionMessageKeyComponents {
+    index: number;
+    material: SessionMessageKeyMaterial;
+}
+
+export interface SessionRecordComponents {
+    currentSession: SessionComponents | undefined;
+    previousSessions: SessionComponents[];
+}
+
+export interface WasmAllocationSnapshot {
+    /**
+     * Whether allocator-level diagnostics were compiled in.
+     */
+    enabled: boolean;
+    /**
+     * Committed WebAssembly linear memory (pages × 64 KiB).
+     */
+    linearBytes: number;
+    /**
+     * Sum of requested sizes of allocations currently alive.
+     */
+    heapLiveBytes: number;
+    /**
+     * Peak requested live bytes since `beginWasmAllocationProfile()`.
+     */
+    heapPeakLiveBytes: number;
+    /**
+     * Cumulative requested allocation/deallocation churn.
+     */
+    allocatedBytes: number;
+    freedBytes: number;
+    allocations: number;
+    deallocations: number;
+    reallocations: number;
+    largestAllocationBytes: number;
+    /**
+     * Mutually exclusive allocation-site buckets. Core task allocation is a
+     * second measurement through the core\'s `AllocMeter`, exposed on the
+     * client for cross-checking this host-side scope.
+     */
+    other: AllocationBucketSnapshot;
+    coreTask: AllocationBucketSnapshot;
+    historyDecode: AllocationBucketSnapshot;
+    historySerialize: AllocationBucketSnapshot;
+    historyEnvelope: AllocationBucketSnapshot;
+    historyCallback: AllocationBucketSnapshot;
+    /**
+     * Allocations performed by the profiler while materializing snapshots.
+     * Kept separate so observation overhead cannot masquerade as workload.
+     */
+    diagnostics: AllocationBucketSnapshot;
+    historySync: HistorySyncAllocationSnapshot;
+    /**
+     * Dynamic attribution sourced from core tracing callsites.
+     */
+    coreSpans: CoreSpanAllocationSnapshot[];
+    /**
+     * Chronological allocator calls that triggered `memory.grow` since the
+     * last `beginWasmAllocationProfile()`.
+     */
+    memoryGrowEvents: AllocationEventSnapshot[];
+    /**
+     * All allocations at or above `large_allocation_threshold_bytes`, whether
+     * they reused committed pages or triggered a grow.
+     */
+    largeAllocationEvents: AllocationEventSnapshot[];
+    largeAllocationThresholdBytes: number;
+    droppedCoreSpanCallsites: number;
+    droppedMemoryGrowEvents: number;
+    droppedLargeAllocationEvents: number;
+}
+
+export type LegacySessionProjectionV1 = { status: "projected"; record: LegacySessionRecordV1 } | { status: "unrepresentable"; issue: LegacySessionProjectionIssueV1 };
+
+export type LegacySessionUnrepresentableFieldV1 = "session_version" | "sender_chain" | "pending_key_exchange" | "post_quantum_pre_key" | "refresh_state" | "derived_message_key" | "last_remote_ephemeral_key";
+
+export type SessionMessageKeyMaterial = { kind: "seed"; seed: Uint8Array } | { kind: "derived"; cipherKey: Uint8Array; macKey: Uint8Array; iv: Uint8Array };
+
+export type WhatsAppEvent =
+| { type: 'receipt'; data: Receipt }
+| { type: 'server_ack'; data: ServerAck }
+| { type: 'undecryptable_message'; data: UndecryptableMessage }
+| { type: 'chat_presence'; data: ChatPresenceUpdate }
+| { type: 'presence'; data: PresenceUpdate }
+| { type: 'picture_update'; data: PictureUpdate }
+| { type: 'user_about_update'; data: UserAboutUpdate }
+| { type: 'contact_updated'; data: ContactUpdated }
+| { type: 'contact_number_changed'; data: ContactNumberChanged }
+| { type: 'contact_sync_requested'; data: ContactSyncRequested }
+| { type: 'group_update'; data: GroupUpdate }
+| { type: 'contact_update'; data: ContactUpdate }
+| { type: 'push_name_update'; data: PushNameUpdate }
+| { type: 'self_push_name_updated'; data: SelfPushNameUpdated }
+| { type: 'pin_update'; data: PinUpdate }
+| { type: 'mute_update'; data: MuteUpdate }
+| { type: 'archive_update'; data: ArchiveUpdate }
+| { type: 'star_update'; data: StarUpdate }
+| { type: 'mark_chat_as_read_update'; data: MarkChatAsReadUpdate }
+| { type: 'delete_chat_update'; data: DeleteChatUpdate }
+| { type: 'clear_chat_update'; data: ClearChatUpdate }
+| { type: 'user_status_mute_update'; data: UserStatusMuteUpdate }
+| { type: 'delete_message_for_me_update'; data: DeleteMessageForMeUpdate }
+| { type: 'label_edit_update'; data: LabelEditUpdate }
+| { type: 'label_association_update'; data: LabelAssociationUpdate }
+| { type: 'offline_sync_preview'; data: OfflineSyncPreview }
+| { type: 'offline_sync_completed'; data: OfflineSyncCompleted }
+| { type: 'dirty_state'; data: { dirty_type: DirtyType; timestamp?: number | null } }
+| { type: 'device_list_update'; data: DeviceListUpdate }
+| { type: 'identity_change'; data: IdentityChange }
+| { type: 'business_status_update'; data: BusinessStatusUpdate }
+| { type: 'temporary_ban'; data: TemporaryBan }
+| { type: 'connect_failure'; data: ConnectFailure }
+| { type: 'stream_error'; data: StreamError }
+| { type: 'disappearing_mode_changed'; data: DisappearingModeChanged }
+| { type: 'newsletter_live_update'; data: NewsletterLiveUpdate }
+| { type: 'incoming_call'; data: IncomingCall }
+| { type: 'missed_call'; data: MissedCall }
+| { type: 'call_ended_elsewhere'; data: CallEndedElsewhere }
+| { type: 'mex_notification'; data: MexNotification }
+| { type: 'pairing_code_refresh'; data: PairingCodeRefresh }
+| { type: 'pair_passkey_request'; data: PairPasskeyRequest }
+| { type: 'pair_passkey_confirmation'; data: PairPasskeyConfirmation }
+| { type: 'pair_passkey_error'; data: PairPasskeyError }
+| { type: 'connected'; data: Record<string, never> }
+| { type: 'disconnected'; data: Record<string, never> }
+| { type: 'qr'; data: { code: string; timeout: number } }
+| { type: 'pairing_code'; data: { code: string; timeout: number } }
+| { type: 'pair_success'; data: { id: string; lid: string; business_name: string; platform: string } }
+| { type: 'pair_error'; data: { id: string; lid: string; business_name: string; platform: string; error: string } }
+| { type: 'logged_out'; data: { on_connect: boolean; reason: string } }
+| { type: 'message'; data: { message: Record<string, unknown>; info: MessageInfo & { is_view_once: boolean } } }
+| { type: 'notification'; data: { tag: string; attrs: Record<string, string>; content?: unknown } }
+| { type: 'stream_replaced'; data: Record<string, never> }
+| { type: 'qr_scanned_without_multidevice'; data: Record<string, never> }
+| { type: 'client_outdated'; data: Record<string, never> }
+| { type: 'raw_node'; data: { tag: string; attrs: Record<string, string>; content?: unknown } }
+| { type: 'history_sync'; data: import('./proto-types').proto.IHistorySync & { syncType: number; chunkOrder?: number; progress?: number; peerDataRequestSessionId?: string } }
+;
+
+
+
+export class IntoUnderlyingByteSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableByteStreamController): Promise<any>;
+    start(controller: ReadableByteStreamController): void;
+    readonly autoAllocateChunkSize: number;
+    readonly type: ReadableStreamType;
+}
+
+export class IntoUnderlyingSink {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    abort(reason: any): Promise<any>;
+    close(): Promise<any>;
+    write(chunk: any): Promise<any>;
+}
+
+export class IntoUnderlyingSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cancel(): void;
+    pull(controller: ReadableStreamDefaultController): Promise<any>;
+}
+
+/**
+ * Opaque handle to the WhatsApp client.
+ */
+export class WasmWhatsAppClient {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Confirm an inbound stanza through the core-owned acknowledgement path.
+     */
+    acknowledgeStanza(stanza_js: BinaryNode): Promise<void>;
+    /**
+     * Add linked-identifier mappings through one durable core batch.
+     */
+    addLidPnMappings(mappings: LidPnMappingInput[]): Promise<number>;
+    /**
+     * Archive or unarchive a chat.
+     */
+    archiveChat(jid: string, archive: boolean): Promise<void>;
+    /**
+     * Ensure E2E Signal sessions exist for the given JIDs.
+     * Returns true after sessions are established.
+     */
+    assertSessions(jids: string[], _force: boolean): Promise<boolean>;
+    /**
+     * Clear a chat's messages while keeping the chat (WA Web's clearChat), via an
+     * app-state mutation. `delete_starred` also removes starred messages and
+     * `delete_media` also removes downloaded media (both flags live in the mutation
+     * index, not the proto). Mirrors `deleteChat` in passing `None` for the message
+     * range, i.e. clears the whole chat.
+     */
+    clearChat(jid: string, delete_starred: boolean, delete_media: boolean): Promise<void>;
+    /**
+     * Update participants of a parent group. Removing a participant also
+     * removes them from its linked groups.
+     */
+    communityParticipantsUpdate(jid: string, participants: string[], action: GroupParticipantAction): Promise<ParticipantChangeResult[]>;
+    /**
+     * Connect to WhatsApp servers (single connection, no auto-reconnect).
+     */
+    connect(): Promise<void>;
+    /**
+     * Create a parent group with explicit protocol options.
+     */
+    createCommunity(name: string, description: string | null | undefined, closed: boolean, allow_non_admin_sub_group_creation: boolean, create_general_chat: boolean): Promise<GroupMetadataResult>;
+    /**
+     * Create a subgroup already linked to a parent group.
+     */
+    createCommunitySubgroup(name: string, participants: string[], parent_jid: string): Promise<GroupMetadataResult>;
+    /**
+     * Create a new group.
+     *
+     * Returns the full `GroupMetadataResult` parsed directly from the
+     * server's create response — no follow-up `getGroupMetadata` IQ
+     * needed. Mirrors the reference client: the create reply
+     * already carries the complete `<group>` node (id, subject,
+     * creation, creator, participants, …).
+     */
+    createGroup(subject: string, participants: string[]): Promise<GroupMetadataResult>;
+    /**
+     * Create encrypted participant `<to>` nodes for recipient JIDs.
+     * Returns `{ nodes: [...], shouldIncludeDeviceIdentity: boolean }`.
+     * Use `encodeProto('Message', obj)` on the JS side to produce the bytes.
+     */
+    createParticipantNodesBytes(jids: string[], bytes: Uint8Array, _extra_attrs: any): Promise<any>;
+    /**
+     * Create and send a poll. Returns `{ messageId, messageSecret }`.
+     *
+     * The `messageSecret` (32 bytes) is needed to decrypt votes later.
+     */
+    createPoll(jid: string, name: string, options: string[], selectable_count: number): Promise<CreatePollResult>;
+    /**
+     * Deactivate a parent group without deleting its former subgroups.
+     */
+    deactivateCommunity(jid: string): Promise<void>;
+    /**
+     * Delete a chat via app state mutation.
+     */
+    deleteChat(jid: string): Promise<void>;
+    /**
+     * Delete a message for self (not for everyone).
+     */
+    deleteMessageForMe(jid: string, message_id: string, from_me: boolean): Promise<void>;
+    /**
+     * Disconnect the client and flush pending state to storage.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Download and decrypt media from raw parameters.
+     *
+     * Handles CDN failover, auth refresh, HMAC-SHA256 verification, and
+     * AES-256-CBC decryption internally. Returns decrypted media bytes.
+     */
+    downloadMedia(direct_path: string, media_key: Uint8Array, file_sha256: Uint8Array, file_enc_sha256: Uint8Array, file_length: number, media_type: MediaType): Promise<Uint8Array>;
+    /**
+     * Download, decrypt, and return a Web ReadableStream of decrypted chunks.
+     *
+     * Same as `downloadMedia` but returns a `ReadableStream` instead of buffering
+     * the entire file. In Node.js, consume with `Readable.fromWeb(stream)`.
+     */
+    downloadMediaStream(direct_path: string, media_key: Uint8Array, file_sha256: Uint8Array, file_enc_sha256: Uint8Array, file_length: number, media_type: MediaType): ReadableStream;
+    /**
+     * Edit a previously sent message from protobuf bytes.
+     */
+    editMessageBytes(jid: string, message_id: string, bytes: Uint8Array): Promise<string>;
+    /**
+     * True streaming encrypt via `MediaEncryptor`: processes plaintext chunk-by-chunk
+     * from JS ReadableStream, encrypts with AES-256-CBC, writes ciphertext to JS WritableStream.
+     *
+     * Peak memory: ~130KB (copy buffer + flush buffer + crypto state).
+     */
+    encryptMediaStream(input: ReadableStream, output: WritableStream, media_type: MediaType): Promise<EncryptMediaResult>;
+    /**
+     * Replenish the server's one-time key pool only when it is low.
+     */
+    ensurePreKeys(): Promise<void>;
+    /**
+     * Fetch the full blocklist.
+     */
+    fetchBlocklist(): Promise<BlocklistEntryResult[]>;
+    /**
+     * Request on-demand message history from the primary phone.
+     * Returns the message ID of the PDO request.
+     * Results will arrive as history_sync events.
+     */
+    fetchMessageHistory(count: number, chat_jid: string, oldest_msg_id: string, oldest_msg_from_me: boolean, oldest_msg_timestamp_ms: number): Promise<string>;
+    /**
+     * Fetch all privacy settings.
+     */
+    fetchPrivacySettings(): Promise<any>;
+    /**
+     * Fetch the account's reachout-timelock state.
+     *
+     * Wraps the `WAWebMexFetchReachoutTimelockJobQuery` MEX persisted
+     * query (id sourced from `wacore::iq::mex_operations::fetch_reachout_timelock`)
+     * and returns the `xwa2_fetch_account_reachout_timelock` payload as a
+     * raw JSON object — typically:
+     *
+     * ```json
+     * { "is_active": true,
+     *   "time_enforcement_ends": "1734567890",
+     *   "enforcement_type": "BIZ_COMMERCE_VIOLATION_…" }
+     * ```
+     *
+     * Returns `null` when the server has no timelock for this account.
+     * Callers map snake_case → idiomatic shape themselves.
+     */
+    fetchReachoutTimelock(): Promise<any>;
+    /**
+     * Fetch user status/about text for one or more JIDs.
+     */
+    fetchStatus(jids: string[]): Promise<FetchStatusResult[]>;
+    /**
+     * Get the ADV signed device identity (account), if available.
+     * Exposes the persisted account identity to credential consumers.
+     */
+    getAccount(): Promise<any>;
+    /**
+     * Get business profile information for a JID.
+     */
+    getBusinessProfile(jid: string): Promise<BusinessProfileResult | undefined>;
+    /**
+     * Fetch subgroups of a parent group.
+     */
+    getCommunitySubgroups(parent_jid: string): Promise<CommunitySubgroupResult[]>;
+    /**
+     * Allocation churn for work polled by whatsapp-rust's instrumented
+     * runtime. It overlaps the global allocator totals but uniquely separates
+     * core task work from bridge/host-boundary work.
+     */
+    getCoreAllocationSnapshot(): CoreAllocationSnapshotResult;
+    /**
+     * Get metadata for a group.
+     */
+    getGroupMetadata(jid: string): Promise<GroupMetadataResult>;
+    /**
+     * Get the own JID (phone number JID) if logged in.
+     *
+     * Returns the non-AD JID (without device suffix), e.g. "559980000014@s.whatsapp.net".
+     * This is the JID used for addressing in messages.
+     */
+    getJid(): Promise<string | undefined>;
+    /**
+     * Get the own LID (linked identity) if available.
+     *
+     * Returns the non-AD LID (without device suffix), e.g. "100000012345678@lid".
+     */
+    getLid(): Promise<string | undefined>;
+    /**
+     * Get media connection info (auth token + upload hosts).
+     *
+     * Returns `{ auth: string, ttl: number, hosts: [{hostname: string, maxContentLengthBytes: number}] }`.
+     */
+    getMediaConn(force: boolean): Promise<MediaConnResult>;
+    /**
+     * Returns a snapshot of internal memory diagnostics (cache sizes, session counts, etc.).
+     */
+    getMemoryDiagnostics(): Promise<MemoryDiagnosticsResult>;
+    /**
+     * Get the current push name.
+     */
+    getPushName(): Promise<string>;
+    /**
+     * Get the list of known devices for the given user JIDs via usync query.
+     * Returns an array of JID strings (one per device).
+     */
+    getUSyncDevices(jids: string[], _use_cache: boolean, _ignore_zero_devices: boolean): Promise<any>;
+    /**
+     * Join a group using an invite code.
+     */
+    groupAcceptInvite(code: string): Promise<string>;
+    /**
+     * Join a group via a GroupInviteMessage (V4 invite).
+     */
+    groupAcceptInviteV4(group_jid: string, code: string, expiration: number, admin_jid: string): Promise<string>;
+    /**
+     * Get group info from an invite code (without joining).
+     * Returns the same shape as groupMetadata.
+     */
+    groupGetInviteInfo(code: string): Promise<GroupMetadataResult>;
+    /**
+     * Get the invite link for a group.
+     */
+    groupInviteCode(jid: string): Promise<string>;
+    /**
+     * Leave a group.
+     */
+    groupLeave(jid: string): Promise<void>;
+    /**
+     * Set who can add members to a group.
+     */
+    groupMemberAddMode(jid: string, mode: MemberAddMode): Promise<void>;
+    /**
+     * Update group participants.
+     */
+    groupParticipantsUpdate(jid: string, participants: string[], action: GroupParticipantAction): Promise<ParticipantChangeResult[]>;
+    /**
+     * Get list of pending join requests for a group.
+     */
+    groupRequestParticipantsList(jid: string): Promise<MembershipRequestResult[]>;
+    /**
+     * Approve or reject pending join requests.
+     */
+    groupRequestParticipantsUpdate(jid: string, participants: string[], action: GroupRequestAction): Promise<ParticipantChangeResult[]>;
+    /**
+     * Revoke a group's invite link (generates new one).
+     */
+    groupRevokeInvite(jid: string): Promise<string>;
+    /**
+     * Revoke invitation codes previously issued to participants.
+     */
+    groupRevokeInviteV4(group_jid: string, invited_jid: string): Promise<boolean>;
+    /**
+     * Update a group setting (locked, announce, membership_approval).
+     */
+    groupSettingUpdate(jid: string, setting: GroupSetting, value: boolean): Promise<void>;
+    /**
+     * Set disappearing messages timer for a group (0 to disable).
+     */
+    groupToggleEphemeral(jid: string, expiration: number): Promise<void>;
+    /**
+     * Update a group's description. Pass null/undefined to remove.
+     */
+    groupUpdateDescription(jid: string, description?: string | null): Promise<void>;
+    /**
+     * Update a group's subject (name).
+     */
+    groupUpdateSubject(jid: string, subject: string): Promise<void>;
+    /**
+     * Check if the client is connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Check if the client is logged in (paired).
+     */
+    isLoggedIn(): boolean;
+    /**
+     * Check if one or more phone numbers / JIDs are registered on WhatsApp.
+     *
+     * Accepts either bare phone numbers (treated as PN JIDs) or full JIDs
+     * (`@s.whatsapp.net` for PN, `@lid` for LID). Mixed PN/LID inputs are
+     * transparently split into the two underlying usync queries by the core,
+     * so a single call is at most two IQs regardless of input size.
+     *
+     * Returns one `IsOnWhatsAppResult` per server hit — including the LID
+     * counterpart and business flag — eliminating the follow-up `fetchUserInfo`
+     * round trip the previous single-phone API forced callers into.
+     */
+    isOnWhatsApp(phones: string[]): Promise<IsOnWhatsAppResult[]>;
+    /**
+     * Convert a JID string to its Signal protocol address representation.
+     */
+    jidToSignalProtocolAddress(jid: string): string;
+    /**
+     * Look up the LID JID corresponding to a given phone number JID.
+     *
+     * Accepts a bare phone number (treated as PN), a `<phone>@s.whatsapp.net`
+     * JID, or any LID/PN JID. Returns the full LID JID string (e.g.
+     * `100000012345678@lid`) or `null` when no mapping is known. Backed by
+     * the core's cache-aside `get_lid_pn_entry`: hits the in-memory cache
+     * first, then falls through to `backend.get_pn_mapping(user)` so a JS
+     * `JsStoreCallbacks` backend without a list primitive still resolves
+     * every persisted mapping without an extra usync round trip.
+     */
+    lidForPn(jid: string): Promise<string | undefined>;
+    /**
+     * Link existing groups to a parent group.
+     */
+    linkCommunitySubgroups(parent_jid: string, subgroup_jids: string[]): Promise<CommunityLinkResult>;
+    /**
+     * Logout from WhatsApp — deregisters this companion device and disconnects.
+     *
+     * Sends `remove-companion-device` IQ to the server (best-effort),
+     * then disconnects. Does NOT clear stored keys — the caller should
+     * delete the store to fully clear credentials.
+     */
+    logout(): Promise<void>;
+    /**
+     * Mark a chat as read or unread via app state mutation.
+     * Different from readMessages (which sends read receipts).
+     */
+    markChatAsRead(jid: string, read: boolean): Promise<void>;
+    /**
+     * Mark voice/video notes as played by sending played receipts
+     * (`<receipt type="played"|"played-self">`). Groups keys by chat +
+     * participant exactly like [`Self::read_messages`]; the core picks
+     * `played` vs `played-self` (newsletters) and sets `participant` only for
+     * group/broadcast chats, so the JS side just hands over the message keys.
+     */
+    markPlayed(keys: ReadMessageKey[]): Promise<void>;
+    /**
+     * Mute or unmute a chat.
+     *
+     * Pass a positive timestamp (ms) to mute until that time, or null/undefined to unmute.
+     */
+    muteChat(jid: string, mute_until?: number | null): Promise<void>;
+    /**
+     * Create a new newsletter (channel).
+     */
+    newsletterCreate(name: string, description?: string | null): Promise<NewsletterMetadataResult>;
+    /**
+     * Fetch metadata for a newsletter by JID.
+     */
+    newsletterMetadata(jid: string): Promise<NewsletterMetadataResult>;
+    /**
+     * Mute or unmute a newsletter's follower-activity notifications — the channel
+     * mute a subscriber toggles (WA Web `MUTE_FOLLOWER_ACTIVITY`). `muted = true`
+     * silences them. The separate owner-only admin-activity mute is not exposed.
+     */
+    newsletterMute(jid: string, muted: boolean): Promise<void>;
+    /**
+     * Send a reaction to a newsletter message.
+     *
+     * `server_id` is the server-assigned message ID (passed as string to avoid
+     * JS number precision issues). `reaction` is the emoji code, or null/empty
+     * to remove a reaction.
+     */
+    newsletterReactMessage(jid: string, server_id: string, reaction?: string | null): Promise<void>;
+    /**
+     * Subscribe (join) a newsletter.
+     */
+    newsletterSubscribe(jid: string): Promise<NewsletterMetadataResult>;
+    /**
+     * Unsubscribe (leave) a newsletter.
+     */
+    newsletterUnsubscribe(jid: string): Promise<void>;
+    /**
+     * Pin or unpin a chat.
+     */
+    pinChat(jid: string, pin: boolean): Promise<void>;
+    /**
+     * Look up the phone number JID corresponding to a given LID JID.
+     *
+     * Accepts a bare LID user-part, a `<user>@lid` JID, or any LID/PN JID.
+     * Returns the full PN JID string (e.g. `559980000001@s.whatsapp.net`) or
+     * `null` when no mapping is known. Same cache-aside semantics as
+     * `lidForPn` — see that doc.
+     */
+    pnForLid(jid: string): Promise<string | undefined>;
+    /**
+     * Subscribe to a contact's presence updates.
+     */
+    presenceSubscribe(jid: string): Promise<void>;
+    /**
+     * Get the profile picture URL for a user or group.
+     *
+     * `picture_type` should be "preview" or "image".
+     */
+    profilePictureUrl(jid: string, picture_type: PictureType, timeout_ms?: number | null): Promise<ProfilePictureInfo | undefined>;
+    /**
+     * Send an IQ node and return the matching response node.
+     */
+    queryNode(node_js: BinaryNode, timeout_ms?: number | null): Promise<BinaryNode>;
+    /**
+     * Execute a validated typed USync query through the core-owned operation.
+     * The bridge performs exactly one Serde decode and one Serde encode; it
+     * neither constructs protocol nodes nor translates consumer-facing names.
+     */
+    queryUsync(query: UsyncQuery): Promise<UsyncResponse>;
+    /**
+     * Mark messages as read by sending read receipts.
+     */
+    readMessages(keys: ReadMessageKey[]): Promise<void>;
+    /**
+     * Drop the current connection and reconnect immediately, picking up
+     * any profile changes (e.g. `setClientProfile`) on the new handshake.
+     * The `run()` loop continues — only the in-flight WebSocket is reset.
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Force-refresh the server's one-time key pool.
+     */
+    refreshPreKeys(count?: number | null): Promise<void>;
+    /**
+     * Reject an incoming call.
+     */
+    rejectCall(call_id: string, peer: string, call_creator: string): Promise<void>;
+    /**
+     * Reject an inbound stanza through the core-owned acknowledgement path.
+     */
+    rejectStanza(stanza_js: BinaryNode, error_code: number, failure_reason?: number | null): Promise<void>;
+    /**
+     * Low-level message relay from protobuf binary bytes.
+     */
+    relayMessageBytes(jid: string, bytes: Uint8Array, message_id?: string | null): Promise<string>;
+    /**
+     * Send an E2E message with neutral core-owned controls.
+     *
+     * Child nodes are converted only at the boundary. Routing, cache policy,
+     * encryption and reserved-node validation remain owned by the core.
+     */
+    relayMessageBytesWithOptions(jid: string, bytes: Uint8Array, message_id: string | null | undefined, extra_nodes: BinaryNode[], refresh_group_metadata: boolean, refresh_devices: boolean): Promise<string>;
+    /**
+     * Remove a group's profile picture.
+     */
+    removeGroupProfilePicture(group_jid: string): Promise<ProfilePictureResult>;
+    /**
+     * Remove the profile picture for the logged-in user.
+     */
+    removeProfilePicture(): Promise<ProfilePictureResult>;
+    /**
+     * Request the server to re-upload expired media.
+     *
+     * Returns the new `directPath` on success.
+     * Throws on failure (not found, decryption error, timeout, etc.).
+     */
+    requestMediaReupload(msg_id: string, chat_jid: string, media_key: Uint8Array, is_from_me: boolean, participant?: string | null): Promise<string>;
+    /**
+     * Request retransmission without acknowledging the original stanza.
+     */
+    requestMessageRetry(stanza_js: BinaryNode, force_include_keys?: boolean | null): Promise<void>;
+    /**
+     * Request a pairing code for phone number login (alternative to QR).
+     *
+     * Returns the 8-character pairing code to enter on the phone. On error,
+     * throws a `WhatsAppError` with structured fields (`kind`, `serverCode`,
+     * `serverText`, etc.) — see `errors::BridgeError`.
+     */
+    requestPairingCode(phone_number: string, custom_code?: string | null): Promise<string>;
+    /**
+     * Retransmit an existing message to one requesting device.
+     */
+    retransmitMessageBytes(chat_jid: string, bytes: Uint8Array, input: MessageRetransmissionInput): Promise<void>;
+    /**
+     * Revoke (delete) a sent message.
+     */
+    revokeMessage(jid: string, message_id: string, participant?: string | null): Promise<void>;
+    /**
+     * Rotate the signed key advertised by the server.
+     */
+    rotateSignedKey(): Promise<void>;
+    /**
+     * Start the main client loop in the background.
+     *
+     * Spawns the connection loop (connect, handshake, message loop, reconnect)
+     * as a background task and returns immediately. The loop runs until `disconnect()`
+     * is called.
+     *
+     * Not `async` to avoid holding a wasm-bindgen borrow on `self` that would
+     * prevent calling other methods (disconnect, etc.).
+     */
+    run(): void;
+    /**
+     * Save or rename a contact, syncing the name to the user's linked devices
+     * (a `contact` app-state mutation). `jid` must be a bare phone-number JID
+     * (the core rejects LID/group/device-specific JIDs).
+     */
+    saveContact(jid: string, full_name: string | null | undefined, first_name: string | null | undefined, save_on_primary_addressbook: boolean): Promise<void>;
+    /**
+     * Send a chat state update (typing indicator).
+     */
+    sendChatState(jid: string, state: ChatState): Promise<void>;
+    /**
+     * Comment on a channel (CAG) post. `bytes` is the encoded body `Message`
+     * proto (encoding belongs to JS, like `sendMessageBytes`); `parent_key`
+     * references the post: `participant` is the post author, or `fromMe: true`
+     * for your own post (the core then resolves your LID/PN as the author).
+     * Requires the parent's `messageSecret`, captured when the post was
+     * received — the core derives the addon key and sends the encrypted
+     * comment envelope. Returns the comment's message id.
+     */
+    sendCommentBytes(jid: string, parent_key: TargetMessageKey, bytes: Uint8Array): Promise<string>;
+    /**
+     * Send an E2E encrypted message from protobuf bytes.
+     * Use `encodeProto('Message', obj)` on the JS side to produce the bytes.
+     */
+    sendMessageBytes(jid: string, bytes: Uint8Array): Promise<string>;
+    /**
+     * Send a raw binary node stanza to WhatsApp servers.
+     * Accepts a JS object matching `{ tag: string, attrs: Record<string, string>, content?: ... }`.
+     */
+    sendNode(node_js: BinaryNode): Promise<void>;
+    /**
+     * Send presence status ("available" or "unavailable").
+     */
+    sendPresence(status: PresenceStatus): Promise<void>;
+    /**
+     * Send pre-marshaled bytes through the noise socket.
+     */
+    sendRawMessage(data: Uint8Array): Promise<void>;
+    /**
+     * React to a DM, group, or status@broadcast message. Empty/null `emoji`
+     * removes a previous reaction. For group/status targets `key.participant`
+     * must carry the original sender (DMs don't need it; for your own message
+     * `fromMe: true` suffices). For a Community Announcement Group the core
+     * encrypts the reaction with the target's `messageSecret` and sends
+     * `enc_reaction_message` (WA Web `WAWebReactionEncryptMsgData`) — plaintext
+     * reactions are rejected there, so this path must be used instead of a
+     * JS-built `reactionMessage` proto. Returns the reaction's message id.
+     */
+    sendReaction(jid: string, key: TargetMessageKey, emoji?: string | null): Promise<string>;
+    /**
+     * Send a status/story message to specified recipients.
+     * Use `encodeProto('Message', obj)` on the JS side to produce the bytes.
+     */
+    sendStatusMessageBytes(bytes: Uint8Array, recipients: string[]): Promise<string>;
+    /**
+     * Send a status message with a caller-provided ID, neutral child nodes and
+     * an explicit recipient-device freshness policy.
+     */
+    sendStatusMessageBytesWithOptions(bytes: Uint8Array, recipients: string[], message_id: string | null | undefined, extra_nodes: BinaryNode[], refresh_devices: boolean): Promise<string>;
+    /**
+     * Enable or disable automatic reconnection on disconnect.
+     * Enabled by default. When disabled, the client will not attempt
+     * to reconnect after an unexpected disconnection.
+     */
+    setAutoReconnect(enabled: boolean): void;
+    /**
+     * Override the noise-handshake `ClientPayload` profile (UserAgent
+     * platform/device/os_version/manufacturer + `web_info` presence).
+     *
+     * Independent of `setDeviceProps`: that one drives the "Linked Devices"
+     * display on the phone; this one drives what the server sees during the
+     * noise handshake. Use `{ preset: 'android', osVersion: '13' }` to set
+     * `UserAgent.platform = ANDROID` and omit `web_info`.
+     *
+     * Runtime-only — the field is `#[serde(skip)]` in the persisted Device,
+     * so re-apply on every fresh process before `connect()`.
+     */
+    setClientProfile(input: ClientProfileInput): Promise<void>;
+    /**
+     * Override `DeviceProps` before initial pairing. Only takes effect on
+     * the registration node — for already paired sessions this is a no-op
+     * on the wire and the core logs a warning.
+     *
+     * Setting `platformType: 'ANDROID_PHONE'` flips the phone's "Linked
+     * Devices" display to Android and unlocks server-side feature gating
+     * (e.g. view-once delivered as payload instead of `absent` stub) WITHOUT
+     * switching the underlying transport — the client still speaks the web
+     * protocol. Real Android companion mode (CRSC v2/v3, TEE attestation)
+     * is NOT implemented; if the server starts enforcing companion-type
+     * crypto, those connections may break.
+     */
+    setDeviceProps(input: DevicePropsInput): Promise<void>;
+    /**
+     * Set the profile picture for a group the user administers.
+     *
+     * Mirrors the core `SetProfilePictureSpec::set_group` path — same IQ as
+     * the self update, just routed at the JID level so admins can change a
+     * group's avatar from JS without an extra capability check.
+     */
+    setGroupProfilePicture(group_jid: string, img_data: Uint8Array): Promise<ProfilePictureResult>;
+    /**
+     * Persist a push name before the first connection handshake.
+     *
+     * This is the WASM equivalent of whatsapp-rust's
+     * `BotBuilder::with_push_name`: it only forwards the value into the
+     * core device state and adds no bridge-specific protocol behavior.
+     */
+    setInitialPushName(name: string): Promise<void>;
+    /**
+     * Set the user's push name (display name).
+     */
+    setPushName(name: string): Promise<void>;
+    /**
+     * Enable or disable raw node forwarding. When enabled, a `raw_node` event
+     * is emitted for every decoded stanza before internal dispatch.
+     */
+    setRawNodeForwarding(enabled: boolean): void;
+    /**
+     * Decrypt a group (sender-key) message.
+     */
+    signalDecryptGroupMessage(group_jid: string, author_jid: string, msg: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt a Signal protocol message. `msg_type` is "msg", "pkmsg", or "skmsg".
+     */
+    signalDecryptMessage(jid: string, msg_type: string, ciphertext: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Delete one sender-key chain from live and durable state.
+     */
+    signalDeleteSenderKey(group_jid: string, sender_jid: string): Promise<void>;
+    /**
+     * Delete Signal sessions for the given JIDs.
+     */
+    signalDeleteSessions(jids: string[]): Promise<void>;
+    /**
+     * Encrypt plaintext for a group (sender key).
+     * Returns `{ senderKeyDistributionMessage: Uint8Array, ciphertext: Uint8Array }`.
+     */
+    signalEncryptGroupMessage(group_jid: string, data: Uint8Array, _me_id: string): Promise<any>;
+    /**
+     * Encrypt plaintext for a single recipient.
+     * Returns `{ type: "msg"|"pkmsg", ciphertext: Uint8Array }`.
+     */
+    signalEncryptMessage(jid: string, data: Uint8Array): Promise<any>;
+    /**
+     * Create the current sender-key distribution payload for a group.
+     */
+    signalGetSenderKeyDistribution(group_jid: string, sender_jid: string): Promise<Uint8Array>;
+    /**
+     * Inspect the currently open pairwise session for a JID.
+     */
+    signalGetSessionInfo(jid: string): Promise<SignalSessionInfoResult | undefined>;
+    /**
+     * Check whether sender-key state exists for a group and sender.
+     */
+    signalHasSenderKey(group_jid: string, sender_jid: string): Promise<boolean>;
+    /**
+     * Install a supplied pairwise pre-key bundle.
+     */
+    signalInstallPreKeyBundle(jid: string, input: SignalSessionBundleInput): Promise<void>;
+    /**
+     * Move pairwise sessions between phone-number and linked-identifier namespaces.
+     */
+    signalMigrateSessions(from_jid: string, to_jid: string): Promise<SignalSessionMigrationResult>;
+    /**
+     * Process a raw sender-key distribution payload.
+     */
+    signalProcessSenderKeyDistribution(group_jid: string, sender_jid: string, distribution: Uint8Array): Promise<void>;
+    /**
+     * Check whether a Signal session exists for the given JID.
+     */
+    signalValidateSession(jid: string): Promise<boolean>;
+    /**
+     * Star or unstar a message.
+     */
+    starMessage(jid: string, message_id: string, star: boolean): Promise<void>;
+    /**
+     * Unlink groups from a parent group.
+     */
+    unlinkCommunitySubgroups(parent_jid: string, subgroup_jids: string[], remove_orphan_members: boolean): Promise<CommunityLinkResult>;
+    /**
+     * Block or unblock a contact.
+     */
+    updateBlockStatus(jid: string, action: BlockAction): Promise<void>;
+    /**
+     * Set default disappearing messages duration (seconds). 0 to disable.
+     */
+    updateDefaultDisappearingMode(duration: number): Promise<void>;
+    /**
+     * Set or clear the bot's per-group "member label" — the small tag rendered
+     * under the bot's display name inside that group's UI. Empty `label`
+     * clears the label. The core sends this as a `ProtocolMessage` over the
+     * normal message path (not an IQ), matching WA Web's behavior.
+     */
+    updateMemberLabel(group_jid: string, label: string): Promise<string>;
+    /**
+     * Update a single privacy setting.
+     */
+    updatePrivacySetting(category: string, value: string): Promise<void>;
+    /**
+     * Set the profile picture for the logged-in user.
+     */
+    updateProfilePicture(img_data: Uint8Array): Promise<ProfilePictureResult>;
+    /**
+     * Update the user's status text (about).
+     */
+    updateProfileStatus(status: string): Promise<void>;
+    /**
+     * Upload pre-encrypted media with streaming body.
+     *
+     * `get_body` is a JS function `() => ReadableStream<Uint8Array>` — called
+     * for each upload attempt (retry creates a fresh stream).
+     * Handles CDN failover, auth refresh, and resumable upload (>=5MB).
+     */
+    uploadEncryptedMediaStream(get_body: Function, media_key: Uint8Array, file_sha256: Uint8Array, file_enc_sha256: Uint8Array, file_length: number, media_type: MediaType): Promise<UploadMediaResult>;
+    /**
+     * Upload media: encrypt in memory + upload with CDN failover and retry.
+     *
+     * Takes raw plaintext bytes. Handles AES-256-CBC encryption, HMAC-SHA256
+     * signing, multi-host CDN upload, auth refresh, and resumable upload (>=5MB).
+     */
+    uploadMedia(data: Uint8Array, media_type: MediaType): Promise<UploadMediaResult>;
+    /**
+     * Validate the server-side key-bundle digest against local state.
+     */
+    validateKeyBundle(): Promise<void>;
+    /**
+     * Vote on a poll. Returns message ID.
+     */
+    votePoll(chat_jid: string, poll_msg_id: string, poll_creator_jid: string, message_secret: Uint8Array, option_names: string[]): Promise<string>;
+}
+
+/**
+ * Start a new peak-observation window without disturbing live/cumulative
+ * counters. The benchmark harness calls this immediately before constructing
+ * a client, then computes churn from successive snapshots.
+ */
+export function beginWasmAllocationProfile(): void;
+
+export function calculateAgreement(public_key: Uint8Array, private_key: Uint8Array): Uint8Array;
+
+export function calculateSignature(private_key: Uint8Array, message: Uint8Array): Uint8Array;
+
+export function decodeSenderKeyRecordComponents(bytes: Uint8Array): SenderKeyRecordComponents;
+
+export function decodeSessionRecordComponents(bytes: Uint8Array): SessionRecordComponents;
+
+export function decryptEventResponsePayload(enc_payload: Uint8Array, enc_iv: Uint8Array, message_secret: Uint8Array, stanza_id: string, event_creator_jid: string, responder_jid: string): Uint8Array;
+
+/**
+ * Decrypt a poll vote. Returns selected option names as a string array.
+ */
+export function decryptPollVote(enc_payload: Uint8Array, enc_iv: Uint8Array, message_secret: Uint8Array, poll_msg_id: string, poll_creator_jid: string, voter_jid: string, option_names: string[]): string[];
+
+export function decryptPollVotePayload(enc_payload: Uint8Array, enc_iv: Uint8Array, message_secret: Uint8Array, stanza_id: string, poll_creator_jid: string, voter_jid: string): Uint8Array;
+
+export function encodeSenderKeyRecordComponents(value: SenderKeyRecordComponents): Uint8Array;
+
+export function encodeSessionRecordComponents(value: SessionRecordComponents): Uint8Array;
+
+export function generateKeyPair(): KeyPair;
+
+/**
+ * Returns which optional features are enabled in this build.
+ * Use this to conditionally call feature-gated functions.
+ */
+export function getEnabledFeatures(): EnabledFeatures;
+
+export function getPublicFromPrivateKey(private_key: Uint8Array): Uint8Array;
+
+/**
+ * Returns current WASM linear memory usage in bytes.
+ *
+ * This is the total memory reserved by the WASM instance (pages × 64KB).
+ * Useful for monitoring memory pressure during media operations.
+ *
+ * Note: this includes free space managed by the allocator — it's the
+ * total memory footprint, not the amount currently in use.
+ */
+export function getWasmMemoryBytes(): number;
+
+export function hasLogger(): boolean;
+
+export function hkdf(input_key_material: Uint8Array, expanded_length: number, options: HkdfInfo): Uint8Array;
+
+export function importLegacySessionRecordV1(record: LegacySessionRecordV1, context: LegacySessionLocalContext): Uint8Array;
+
+/**
+ * Inflate a zlib stream.
+ *
+ * The decompressor and its scratch buffer are pooled per thread, so repeated
+ * calls do not reallocate. `maxOutputBytes` caps the decompressed size and is
+ * rejected before the output can grow past it, which is what keeps a
+ * compression bomb from exhausting linear memory; it defaults to 64 MiB.
+ */
+export function inflateZlib(data: Uint8Array, max_output_bytes?: number | null): Uint8Array;
+
+export function logMessage(level: string, message: string): void;
+
+export function md5(input: Uint8Array): Uint8Array;
+
+export function projectLegacySessionRecordV1(bytes: Uint8Array): LegacySessionProjectionV1;
+
+export function setLogger(logger: ILogger): void;
+
+export function updateLogger(logger: ILogger): void;
+
+export function verifySignature(public_key: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_wasmwhatsappclient_free: (a: number, b: number) => void;
+    readonly beginWasmAllocationProfile: () => void;
+    readonly calculateAgreement: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly calculateSignature: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly createWhatsAppClient: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly decodeSenderKeyRecordComponents: (a: number, b: number, c: number) => void;
+    readonly decodeSessionRecordComponents: (a: number, b: number, c: number) => void;
+    readonly decryptEventResponsePayload: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
+    readonly decryptPollVote: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number) => void;
+    readonly decryptPollVotePayload: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
+    readonly encodeSenderKeyRecordComponents: (a: number, b: number) => void;
+    readonly encodeSessionRecordComponents: (a: number, b: number) => void;
+    readonly generateKeyPair: () => number;
+    readonly getEnabledFeatures: () => number;
+    readonly getPublicFromPrivateKey: (a: number, b: number, c: number) => void;
+    readonly getWasmAllocationSnapshot: (a: number) => void;
+    readonly hasLogger: () => number;
+    readonly hkdf: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly importLegacySessionRecordV1: (a: number, b: number, c: number) => void;
+    readonly inflateZlib: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly initWasmEngine: (a: number, b: number) => void;
+    readonly logMessage: (a: number, b: number, c: number, d: number) => void;
+    readonly md5: (a: number, b: number) => number;
+    readonly projectLegacySessionRecordV1: (a: number, b: number, c: number) => void;
+    readonly setLogger: (a: number, b: number) => void;
+    readonly updateLogger: (a: number) => void;
+    readonly verifySignature: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly wasmwhatsappclient_acknowledgeStanza: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_addLidPnMappings: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_archiveChat: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_assertSessions: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_clearChat: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_communityFetchAllParticipating: (a: number) => number;
+    readonly wasmwhatsappclient_communityParticipantsUpdate: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_connect: (a: number) => number;
+    readonly wasmwhatsappclient_createCommunity: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly wasmwhatsappclient_createCommunitySubgroup: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_createGroup: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_createParticipantNodesBytes: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_createPoll: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly wasmwhatsappclient_deactivateCommunity: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_deleteChat: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_deleteMessageForMe: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_disconnect: (a: number) => number;
+    readonly wasmwhatsappclient_downloadMedia: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => number;
+    readonly wasmwhatsappclient_downloadMediaStream: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
+    readonly wasmwhatsappclient_editMessageBytes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_encryptMediaStream: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_ensurePreKeys: (a: number) => number;
+    readonly wasmwhatsappclient_fetchBlocklist: (a: number) => number;
+    readonly wasmwhatsappclient_fetchMessageHistory: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly wasmwhatsappclient_fetchPrivacySettings: (a: number) => number;
+    readonly wasmwhatsappclient_fetchReachoutTimelock: (a: number) => number;
+    readonly wasmwhatsappclient_fetchStatus: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_fetchUserInfo: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_getAccount: (a: number) => number;
+    readonly wasmwhatsappclient_getBusinessProfile: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_getCommunitySubgroups: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_getCoreAllocationSnapshot: (a: number) => number;
+    readonly wasmwhatsappclient_getGroupMetadata: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_getJid: (a: number) => number;
+    readonly wasmwhatsappclient_getLid: (a: number) => number;
+    readonly wasmwhatsappclient_getMediaConn: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_getMemoryDiagnostics: (a: number) => number;
+    readonly wasmwhatsappclient_getPushName: (a: number) => number;
+    readonly wasmwhatsappclient_getUSyncDevices: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_groupAcceptInvite: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_groupAcceptInviteV4: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly wasmwhatsappclient_groupFetchAllParticipating: (a: number) => number;
+    readonly wasmwhatsappclient_groupGetInviteInfo: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_groupInviteCode: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_groupLeave: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_groupMemberAddMode: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_groupParticipantsUpdate: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_groupRequestParticipantsList: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_groupRequestParticipantsUpdate: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_groupRevokeInvite: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_groupRevokeInviteV4: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_groupSettingUpdate: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_groupToggleEphemeral: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_groupUpdateDescription: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_groupUpdateSubject: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_isConnected: (a: number) => number;
+    readonly wasmwhatsappclient_isLoggedIn: (a: number) => number;
+    readonly wasmwhatsappclient_isOnWhatsApp: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_jidToSignalProtocolAddress: (a: number, b: number, c: number, d: number) => void;
+    readonly wasmwhatsappclient_lidForPn: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_linkCommunitySubgroups: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_logout: (a: number) => number;
+    readonly wasmwhatsappclient_markChatAsRead: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_markPlayed: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_muteChat: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_newsletterCreate: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_newsletterMetadata: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_newsletterMute: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_newsletterReactMessage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_newsletterSubscribe: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_newsletterUnsubscribe: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_pinChat: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_pnForLid: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_presenceSubscribe: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_profilePictureUrl: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_queryNode: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_queryUsync: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_readMessages: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_reconnect: (a: number) => number;
+    readonly wasmwhatsappclient_refreshPreKeys: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_rejectCall: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_rejectStanza: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_relayMessageBytes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_relayMessageBytesWithOptions: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
+    readonly wasmwhatsappclient_removeGroupProfilePicture: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_removeProfilePicture: (a: number) => number;
+    readonly wasmwhatsappclient_requestMediaReupload: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
+    readonly wasmwhatsappclient_requestMessageRetry: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_requestPairingCode: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_retransmitMessageBytes: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_revokeMessage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_rotateSignedKey: (a: number) => number;
+    readonly wasmwhatsappclient_run: (a: number, b: number) => void;
+    readonly wasmwhatsappclient_saveContact: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly wasmwhatsappclient_sendChatState: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_sendCommentBytes: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_sendMessageBytes: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_sendNode: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_sendPresence: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_sendRawMessage: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_sendReaction: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_sendStatusMessageBytes: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_sendStatusMessageBytesWithOptions: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+    readonly wasmwhatsappclient_setAutoReconnect: (a: number, b: number) => void;
+    readonly wasmwhatsappclient_setClientProfile: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_setDeviceProps: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_setGroupProfilePicture: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_setInitialPushName: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_setPushName: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_setRawNodeForwarding: (a: number, b: number) => void;
+    readonly wasmwhatsappclient_signalDecryptGroupMessage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_signalDecryptMessage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_signalDeleteSenderKey: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_signalDeleteSessions: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_signalEncryptGroupMessage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_signalEncryptMessage: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_signalGetSenderKeyDistribution: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_signalGetSessionInfo: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_signalHasSenderKey: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_signalInstallPreKeyBundle: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_signalMigrateSessions: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_signalProcessSenderKeyDistribution: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly wasmwhatsappclient_signalValidateSession: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_starMessage: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_unlinkCommunitySubgroups: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly wasmwhatsappclient_updateBlockStatus: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_updateDefaultDisappearingMode: (a: number, b: number) => number;
+    readonly wasmwhatsappclient_updateMemberLabel: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_updatePrivacySetting: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly wasmwhatsappclient_updateProfilePicture: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_updateProfileStatus: (a: number, b: number, c: number) => number;
+    readonly wasmwhatsappclient_uploadEncryptedMediaStream: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
+    readonly wasmwhatsappclient_uploadMedia: (a: number, b: number, c: number, d: number) => number;
+    readonly wasmwhatsappclient_validateKeyBundle: (a: number) => number;
+    readonly wasmwhatsappclient_votePoll: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => number;
+    readonly getWasmMemoryBytes: () => number;
+    readonly __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
+    readonly __wbg_intounderlyingsink_free: (a: number, b: number) => void;
+    readonly __wbg_intounderlyingsource_free: (a: number, b: number) => void;
+    readonly intounderlyingbytesource_autoAllocateChunkSize: (a: number) => number;
+    readonly intounderlyingbytesource_cancel: (a: number) => void;
+    readonly intounderlyingbytesource_pull: (a: number, b: number) => number;
+    readonly intounderlyingbytesource_start: (a: number, b: number) => void;
+    readonly intounderlyingbytesource_type: (a: number) => number;
+    readonly intounderlyingsink_abort: (a: number, b: number) => number;
+    readonly intounderlyingsink_close: (a: number) => number;
+    readonly intounderlyingsink_write: (a: number, b: number) => number;
+    readonly intounderlyingsource_cancel: (a: number) => void;
+    readonly intounderlyingsource_pull: (a: number, b: number) => number;
+    readonly __wasm_bindgen_func_elem_3793: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_24619: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_24621: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_8208: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_3792: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_3791: (a: number, b: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export5: (a: number, b: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;