@vanzxy/baileys 1.3.7 → 1.3.9

package/lib/Utils/process-message.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Decrypt a poll vote
+ * @param vote encrypted vote
+ * @param ctx additional info about the poll required for decryption
+ * @returns list of SHA256 options
+ */
+export function decryptPollVote({ encPayload, encIv }: {
+    encPayload: any;
+    encIv: any;
+}, { pollCreatorJid, pollMsgId, pollEncKey, voterJid }: {
+    pollCreatorJid: any;
+    pollMsgId: any;
+    pollEncKey: any;
+    voterJid: any;
+}): any;
+/**
+ * Decrypt an event response
+ * @param response encrypted event response
+ * @param ctx additional info about the event required for decryption
+ * @returns event response message
+ */
+export function decryptEventResponse({ encPayload, encIv }: {
+    encPayload: any;
+    encIv: any;
+}, { eventCreatorJid, eventMsgId, eventEncKey, responderJid }: {
+    eventCreatorJid: any;
+    eventMsgId: any;
+    eventEncKey: any;
+    responderJid: any;
+}): any;
+/**
+ * Decrypt a `secretEncryptedMessage` carrying a `MESSAGE_EDIT` payload.
+ *
+ * WhatsApp started wrapping message edits in an E2EE envelope (May 2026).
+ * The new content is encrypted with a key derived from the original
+ * message's `messageContextInfo.messageSecret` using HKDF-SHA256
+ * + AES-256-GCM, same family as polls and event responses but with
+ * different constants (validated against live WhatsApp Android traffic):
+ *
+ *   info = msgId || origSenderJid || editorJid || "Message Edit"
+ *   aad  = (empty)              <-- differs from Poll Vote / Event Response
+ *   key  = HKDF-SHA256(salt=zeros, ikm=messageSecret, info, L=32)
+ *
+ * The decrypted plaintext is a regular `proto.Message` whose
+ * `protocolMessage.editedMessage` field holds the new content — same
+ * shape as the legacy `protocolMessage.editedMessage` edit path, so
+ * consumers can treat the result identically.
+ *
+ * @param edit encrypted edit payload (encPayload + encIv from SecretEncryptedMessage)
+ * @param ctx info about the original message required for decryption
+ * @returns decoded outer `Message` whose `protocolMessage.editedMessage`
+ *   carries the new content (extendedTextMessage / conversation / etc.)
+ */
+export function decryptMessageEdit({ encPayload, encIv }: {
+    encPayload: any;
+    encIv: any;
+}, { originalSenderJid, originalMsgId, editEncKey, editorJid }: {
+    originalSenderJid: any;
+    originalMsgId: any;
+    editEncKey: any;
+    editorJid: any;
+}): any;
+export function cleanMessage(message: any, meId: any, meLid: any): void;
+export function isRealMessage(message: any): boolean;
+export function shouldIncrementChatUnread(message: any): boolean;
+export function getChatId({ remoteJid, participant, fromMe }: {
+    remoteJid: any;
+    participant: any;
+    fromMe: any;
+}): any;
+export default processMessage;
+declare function processMessage(message: any, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, signalRepository, keyStore, logger, options, getMessage }: {
+    shouldProcessHistoryMsg: any;
+    placeholderResendCache: any;
+    ev: any;
+    creds: any;
+    signalRepository: any;
+    keyStore: any;
+    logger: any;
+    options: any;
+    getMessage: any;
+}): Promise<void>;

package/lib/Utils/reporting-utils.d.ts

@@ -0,0 +1,12 @@
+export function shouldIncludeReportingToken(message: any): boolean;
+export function getMessageReportingToken(msgProtobuf: any, message: any, key: any): Promise<{
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {
+            v: string;
+        };
+        content: any;
+    }[];
+} | null>;

package/lib/Utils/rich-message-utils.d.ts

@@ -0,0 +1,48 @@
+export function tokenizeCode(code: any, language?: string): {
+    highlightType: any;
+    codeContent: string;
+}[];
+export function toUnified(submessages: any, uuid: any): {
+    response_id: any;
+    sections: any;
+};
+export function prepareRichResponseMessage(content: any): {
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: {
+                    certificateChain: Uint8Array<ArrayBuffer>[];
+                    version: number;
+                    useCase: number;
+                    signature: Uint8Array<ArrayBuffer>;
+                }[];
+            };
+        };
+    };
+    botForwardedMessage: {
+        message: {
+            richResponseMessage: any;
+        };
+    };
+};
+export function botMetadataSignature(): Uint8Array<ArrayBuffer>;
+export function botMetadataCertificate(length?: number): Uint8Array<ArrayBuffer>;
+export function wrapToBotForwardedMessage(richResponseMessage: any): {
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: {
+                    certificateChain: Uint8Array<ArrayBuffer>[];
+                    version: number;
+                    useCase: number;
+                    signature: Uint8Array<ArrayBuffer>;
+                }[];
+            };
+        };
+    };
+    botForwardedMessage: {
+        message: {
+            richResponseMessage: any;
+        };
+    };
+};

package/lib/Utils/rich-message-utils.js

@@ -11,6 +11,23 @@ import { CodeHighlightType, RichSubMessageType } from '../Types/RichType.js';
 import { proto } from '../../WAProto/index.js';
 import { unixTimestampSeconds } from './generics.js';
 const NOOP = new Set([]);
+// Vanz@Fix (bug 40 / inline image): AIRichResponseInlineImageMetadata.imageUrl is a nested
+// AIRichResponseImageURL message (imagePreviewUrl/imageHighResUrl/sourceUrl), NOT a plain string.
+// Passing a raw string made protobufjs silently encode an empty embedded message (no throw),
+// so the image URL data was dropped on the wire and the image never rendered.
+const toImageUrlObject = (url) => {
+    if (!url)
+        return undefined;
+    if (typeof url === 'object')
+        return { imagePreviewUrl: url.imagePreviewUrl || url.url, imageHighResUrl: url.imageHighResUrl || url.url, sourceUrl: url.sourceUrl || url.url };
+    return { imagePreviewUrl: url, imageHighResUrl: url, sourceUrl: url };
+};
+const IMAGE_ALIGNMENT = { leading: 0, trailing: 1, center: 2 };
+const toImageAlignment = (alignment) => {
+    if (typeof alignment === 'number')
+        return alignment;
+    return IMAGE_ALIGNMENT[String(alignment || 'center').toLowerCase()] ?? IMAGE_ALIGNMENT.center;
+};
 export const tokenizeCode = (code, language = 'javascript') => {
     const keywords = LANGUAGE_KEYWORDS[language] || NOOP;
     const blocks = [];
@@ -75,14 +92,22 @@ export const toUnified = (submessages, uuid) => ({
                     }
                 };
             case RichSubMessageType.INLINE_IMAGE:
-                // Vanz@Fix (bug 40): was returning {} — now renders inline image
+                // Vanz@Fix (bug 40, round 2): imageUrl is now a real AIRichResponseImageURL
+                // object (imagePreviewUrl/imageHighResUrl/sourceUrl) instead of a bare string
+                // that protobufjs silently dropped on encode. alignment is mapped back to its
+                // enum name (matches how the compiled proto's toObject() renders other enums).
                 const imgMeta = submessage.imageMetadata;
+                const ALIGNMENT_NAME = ['AI_RICH_RESPONSE_IMAGE_LAYOUT_LEADING_ALIGNED', 'AI_RICH_RESPONSE_IMAGE_LAYOUT_TRAILING_ALIGNED', 'AI_RICH_RESPONSE_IMAGE_LAYOUT_CENTER_ALIGNED'];
                 return {
                     view_model: {
                         primitive: {
-                            image_url: imgMeta?.imageUrl || '',
+                            image_url: {
+                                image_preview_url: imgMeta?.imageUrl?.imagePreviewUrl || '',
+                                image_high_res_url: imgMeta?.imageUrl?.imageHighResUrl || '',
+                                source_url: imgMeta?.imageUrl?.sourceUrl || ''
+                            },
                             image_text: imgMeta?.imageText || '',
-                            alignment: imgMeta?.alignment || 'center',
+                            alignment: ALIGNMENT_NAME[imgMeta?.alignment ?? 2],
                             tap_link_url: imgMeta?.tapLinkUrl || '',
                             __typename: 'GenAIInlineImageUXPrimitive'
                         },
@@ -167,9 +192,9 @@ export const prepareRichResponseMessage = (content) => {
                 return {
                     messageType: RichSubMessageType.INLINE_IMAGE,
                     imageMetadata: {
-                        imageUrl: submessage.inlineImage,
+                        imageUrl: toImageUrlObject(submessage.inlineImage),
                         imageText: submessage.imageText,
-                        alignment: submessage.alignment,
+                        alignment: toImageAlignment(submessage.alignment),
                         tapLinkUrl: submessage.tapLinkUrl
                     }
                 };
@@ -255,9 +280,9 @@ export const prepareRichResponseMessage = (content) => {
             submessages.push({
                 messageType: RichSubMessageType.INLINE_IMAGE,
                 imageMetadata: {
-                    imageUrl: inlineImage,
+                    imageUrl: toImageUrlObject(inlineImage),
                     imageText,
-                    alignment,
+                    alignment: toImageAlignment(alignment),
                     tapLinkUrl
                 }
             });

package/lib/Utils/signal.d.ts

@@ -0,0 +1,82 @@
+export function createSignalIdentity(wid: any, accountSignatureKey: any): {
+    identifier: {
+        name: any;
+        deviceId: number;
+    };
+    identifierKey: any;
+};
+export function getPreKeys({ get }: {
+    get: any;
+}, min: any, limit: any): Promise<any>;
+export function generateOrGetPreKeys(creds: any, range: any): {
+    newPreKeys: {};
+    lastPreKeyId: number;
+    preKeysRange: any[];
+};
+export function xmppSignedPreKey(key: any): {
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function xmppPreKey(pair: any, id: any): {
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function extractE2ESessionFromRetryReceipt(receipt: any): {
+    registrationId: number | undefined;
+    identityKey: any;
+    signedPreKey: {
+        keyId: number | undefined;
+        publicKey: any;
+        signature: any;
+    };
+    preKey: {
+        keyId: number | undefined;
+        publicKey: any;
+    } | undefined;
+} | null;
+export function parseAndInjectE2ESessions(node: any, repository: any): Promise<void>;
+export function extractDeviceJids(result: any, myJid: any, myLid: any, excludeZeroDevices: any): {
+    user: any;
+    device: any;
+    domainType: any;
+    server: any;
+}[];
+export function getNextPreKeys({ creds, keys }: {
+    creds: any;
+    keys: any;
+}, count: any): Promise<{
+    update: {
+        nextPreKeyId: number;
+        firstUnuploadedPreKeyId: number;
+    };
+    preKeys: any;
+}>;
+export function getNextPreKeysNode(state: any, count: any): Promise<{
+    update: {
+        nextPreKeyId: number;
+        firstUnuploadedPreKeyId: number;
+    };
+    node: {
+        tag: string;
+        attrs: {
+            xmlns: string;
+            type: string;
+            to: string;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: any;
+        }[];
+    };
+}>;

package/lib/Utils/stanza-ack.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+export function buildAckStanza(node: any, errorCode: any, meId: any): {
+    tag: string;
+    attrs: {
+        id: any;
+        to: any;
+        class: any;
+    };
+};

package/lib/Utils/sync-action-utils.d.ts

@@ -0,0 +1,2 @@
+export function processContactAction(action: any, id: any, logger: any): any[];
+export function emitSyncActionResults(ev: any, results: any): void;

package/lib/Utils/tc-token-utils.d.ts

@@ -0,0 +1,29 @@
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export function readTcTokenIndex(keys: any): Promise<any[]>;
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export function buildMergedTcTokenIndexWrite(keys: any, addedJids: any): Promise<{
+    __index: {
+        token: any;
+    };
+}>;
+export function isTcTokenExpired(timestamp: any): boolean;
+export function shouldSendNewTcToken(senderTimestamp: any): boolean;
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export function resolveTcTokenJid(jid: any, getLIDForPN: any): Promise<any>;
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export function resolveIssuanceJid(jid: any, issueToLid: any, getLIDForPN: any, getPNForLID: any): Promise<any>;
+export function buildTcTokenFromJid({ authState, jid, baseContent, getLIDForPN }: {
+    authState: any;
+    jid: any;
+    baseContent?: never[] | undefined;
+    getLIDForPN: any;
+}): Promise<any[] | undefined>;
+export function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }: {
+    result: any;
+    fallbackJid: any;
+    keys: any;
+    getLIDForPN: any;
+    onNewJidStored: any;
+}): Promise<void>;
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY: "__index";

package/lib/Utils/use-multi-file-auth-state.d.ts

@@ -0,0 +1,10 @@
+export function useMultiFileAuthState(folder: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<any>;
+}>;

package/lib/Utils/use-single-file-auth-state.d.ts

@@ -0,0 +1,10 @@
+export function useSingleFileAuthState(fileName: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => {};
+            set: (data: any) => void;
+        };
+    };
+    saveCreds: () => void;
+}>;

package/lib/Utils/use-single-file-auth-state.js

@@ -5,6 +5,7 @@ import { initAuthCreds } from './auth-utils.js';
 import { BufferJSON } from './generics.js';
 import { LRUCache } from 'lru-cache';
 import { Mutex } from 'async-mutex';
+import defaultLogger from './logger.js';
 // Lia@Changes 25-03-26 --- Add useSingleFileAuthState with integrated cache
 const FLUSH_TIMEOUT_MS = 3000;
 // Lia@Changes 22-04-26 --- Enhanced useSingleFileAuthState with LRUCache
@@ -49,7 +50,11 @@ export const useSingleFileAuthState = async (fileName) => {
                     await writeFile(tempFile, JSON.stringify(fileData, BufferJSON.replacer));
                     await rename(tempFile, fileName);
                 }
-                catch { }
+                catch (err) {
+                    // Vanz@Fix (bug 58): was silently swallowed — auth session could fail
+                    // to persist (disk full, permission error, etc.) with zero trace.
+                    defaultLogger.error({ err, fileName }, 'failed to flush auth state to disk');
+                }
             });
         }, FLUSH_TIMEOUT_MS);
     };

package/lib/Utils/use-sqlite-auth-state.d.ts

@@ -0,0 +1,11 @@
+export function useSqliteAuthState(opts: any): Promise<{
+    state: {
+        creds: any;
+        keys: {
+            get: (type: any, ids: any) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
+    };
+    saveCreds: () => Promise<void>;
+    close: () => Promise<void>;
+}>;

package/lib/Utils/use-sqlite-auth-state.js

@@ -125,6 +125,18 @@ export async function useSqliteAuthState(opts) {
         },
         saveCreds: async () => {
             persistCreds(creds);
+        },
+        // Vanz@Fix: release the WAL cleanup interval and (if we opened it ourselves)
+        // the underlying db handle. Without this, every useSqliteAuthState() call
+        // (e.g. re-pairing / rotating sessions) leaked a timer + open sqlite fd forever.
+        close: async () => {
+            clearInterval(_walCleanupInterval);
+            if (!opts.database) {
+                try {
+                    db.close();
+                }
+                catch { /* already closed */ }
+            }
         }
     };
 }

package/lib/Utils/validate-connection.d.ts

@@ -0,0 +1,42 @@
+export function generateLoginNode(userJid: any, config: any): any;
+export function generateRegistrationNode({ registrationId, signedPreKey, signedIdentityKey }: {
+    registrationId: any;
+    signedPreKey: any;
+    signedIdentityKey: any;
+}, config: any): any;
+export function configureSuccessfulPairing(stanza: any, { advSecretKey, signedIdentityKey, signalIdentities }: {
+    advSecretKey: any;
+    signedIdentityKey: any;
+    signalIdentities: any;
+}): {
+    creds: {
+        account: any;
+        me: {
+            id: any;
+            name: any;
+            lid: any;
+        };
+        signalIdentities: any[];
+        platform: any;
+    };
+    reply: {
+        tag: string;
+        attrs: {
+            to: string;
+            type: string;
+            id: any;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: {
+                tag: string;
+                attrs: {
+                    'key-index': any;
+                };
+                content: any;
+            }[];
+        }[];
+    };
+};
+export function encodeSignedDeviceIdentity(account: any, includeSignatureKey: any): any;

package/lib/WABinary/constants.d.ts

@@ -0,0 +1,61 @@
+export namespace TAGS {
+    let LIST_EMPTY: number;
+    let DICTIONARY_0: number;
+    let DICTIONARY_1: number;
+    let DICTIONARY_2: number;
+    let DICTIONARY_3: number;
+    let INTEROP_JID: number;
+    let FB_JID: number;
+    let AD_JID: number;
+    let LIST_8: number;
+    let LIST_16: number;
+    let JID_PAIR: number;
+    let HEX_8: number;
+    let BINARY_8: number;
+    let BINARY_20: number;
+    let BINARY_32: number;
+    let NIBBLE_8: number;
+    let PACKED_MAX: number;
+}
+export const DOUBLE_BYTE_TOKENS: string[][];
+export const SINGLE_BYTE_TOKENS: string[];
+export const TOKEN_MAP: {};
+export const CPP_KEYWORDS: Set<string>;
+export const CSS_KEYWORDS: Set<string>;
+export const GO_KEYWORDS: Set<string>;
+export const HTML_KEYWORDS: Set<string>;
+export const JS_KEYWORDS: Set<string>;
+export const PYTHON_KEYWORDS: Set<string>;
+export const RUST_KEYWORDS: Set<string>;
+export const C_KEYWORDS: Set<string>;
+export const CSHARP_KEYWORDS: Set<string>;
+export const BASH_KEYWORDS: Set<string>;
+export const CMD_KEYWORDS: Set<string>;
+export const POWERSHELL_KEYWORDS: Set<string>;
+export const LANGUAGE_KEYWORDS: {
+    css: Set<string>;
+    html: Set<string>;
+    javascript: Set<string>;
+    typescript: Set<string>;
+    js: Set<string>;
+    ts: Set<string>;
+    python: Set<string>;
+    py: Set<string>;
+    go: Set<string>;
+    golang: Set<string>;
+    cpp: Set<string>;
+    'c++': Set<string>;
+    rust: Set<string>;
+    rs: Set<string>;
+    c: Set<string>;
+    h: Set<string>;
+    csharp: Set<string>;
+    cs: Set<string>;
+    bash: Set<string>;
+    sh: Set<string>;
+    zsh: Set<string>;
+    cmd: Set<string>;
+    bat: Set<string>;
+    powershell: Set<string>;
+    ps1: Set<string>;
+};

package/lib/WABinary/decode.d.ts

@@ -0,0 +1,9 @@
+export function decompressingIfRequired(buffer: any): Promise<any>;
+export function decodeDecompressedBinaryNode(buffer: any, opts: any, indexRef?: {
+    index: number;
+}): {
+    tag: any;
+    attrs: {};
+    content: any;
+};
+export function decodeBinaryNode(buff: any): Promise<any>;

package/lib/WABinary/encode.d.ts

@@ -0,0 +1,2 @@
+export function encodeBinaryNode(node: any, opts?: typeof constants, buffer?: number[]): any;
+import * as constants from './constants.js';

package/lib/WABinary/generic-utils.d.ts

@@ -0,0 +1,74 @@
+export function binaryNodeToString(node: any, i?: number): any;
+export function getBinaryNodeChildren(node: any, childTag: any): any;
+export function getBinaryNodeChild(node: any, childTag: any): any;
+export function getAllBinaryNodeChildren({ content }: {
+    content: any;
+}): any[];
+export function getBinaryNodeChildBuffer(node: any, childTag: any): any;
+export function getBinaryNodeChildString(node: any, childTag: any): any;
+export function getBinaryNodeChildUInt(node: any, childTag: any, length: any): number | undefined;
+export function assertNodeErrorFree(node: any): void;
+export function reduceBinaryNodeToDictionary(node: any, tag: any): any;
+export function getBinaryNodeMessages({ content }: {
+    content: any;
+}): any[];
+export function getBizBinaryNode(message: any): {
+    tag: string;
+    attrs: {
+        actual_actors: string;
+        host_storage: string;
+        privacy_mode_ts: string;
+    };
+    content: ({
+        tag: string;
+        attrs: {
+            decision_id: any;
+            source_type: string;
+        };
+        content: {
+            tag: string;
+            attrs: {
+                value: string;
+            };
+        }[];
+    } | {
+        tag: string;
+        attrs: {
+            type: string;
+            v: string;
+        };
+        content: {
+            tag: string;
+            attrs: {
+                v: string;
+                name: any;
+            };
+        }[];
+    })[];
+} | {
+    tag: string;
+    attrs: {
+        actual_actors: string;
+        host_storage: string;
+        privacy_mode_ts: string;
+    };
+    content: ({
+        tag: string;
+        attrs: {
+            decision_id: any;
+            source_type: string;
+        };
+        content: {
+            tag: string;
+            attrs: {
+                value: string;
+            };
+        }[];
+    } | {
+        tag: string;
+        attrs: {
+            v: string;
+            type: string;
+        };
+    })[];
+};

package/lib/WABinary/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./encode.js";
+export * from "./decode.js";
+export * from "./generic-utils.js";
+export * from "./jid-utils.js";
+export * from "./types.js";

package/lib/WABinary/jid-utils.d.ts

@@ -0,0 +1,28 @@
+export const S_WHATSAPP_NET: "@s.whatsapp.net";
+export const OFFICIAL_BIZ_JID: "16505361212@c.us";
+export const SERVER_JID: "server@c.us";
+export const PSA_WID: "0@c.us";
+export const STORIES_JID: "status@broadcast";
+export const META_AI_JID: "13135550002@c.us";
+export const WAJIDDomains: any;
+export function getServerFromDomainType(initialServer: any, domainType: any): any;
+export function jidEncode(user: any, server: any, device: any, agent: any): string;
+export function jidDecode(jid: any): {
+    server: any;
+    user: any;
+    domainType: any;
+    device: number | undefined;
+} | undefined;
+export function areJidsSameUser(jid1: any, jid2: any): boolean;
+export function isJidMetaAI(jid: any): any;
+export function isPnUser(jid: any): any;
+export function isLidUser(jid: any): any;
+export function isJidBroadcast(jid: any): any;
+export function isJidGroup(jid: any): any;
+export function isJidStatusBroadcast(jid: any): boolean;
+export function isJidNewsletter(jid: any): any;
+export function isHostedPnUser(jid: any): any;
+export function isHostedLidUser(jid: any): any;
+export function isJidBot(jid: any): any;
+export function jidNormalizedUser(jid: any): string;
+export function transferDevice(fromJid: any, toJid: any): string;

package/lib/WABinary/types.d.ts

@@ -0,0 +1,19 @@
+import * as constants from './constants.js';
+/**
+ * the binary node WA uses internally for communication
+ *
+ * this is manipulated soley as an object and it does not have any functions.
+ * This is done for easy serialization, to prevent running into issues with prototypes &
+ * to maintain functional code structure
+ * */
+export type BinaryNode = {
+    tag: string;
+    attrs: {
+        [key: string]: string;
+    };
+    content?: BinaryNode[] | string | Uint8Array;
+};
+export type BinaryNodeAttributes = BinaryNode['attrs'];
+export type BinaryNodeData = BinaryNode['content'];
+export type BinaryNodeCodingOptions = typeof constants;
+//# sourceMappingURL=types.d.ts.map