zapo-js 0.1.0

package/dist/types/transport/binary/constants.d.ts

@@ -0,0 +1,49 @@
+export declare const LIST_EMPTY = 0;
+export declare const STREAM_END = 2;
+export declare const DICTIONARY_0 = 236;
+export declare const DICTIONARY_3 = 239;
+export declare const JID_INTEROP = 245;
+export declare const JID_FB = 246;
+export declare const JID_U = 247;
+export declare const LIST_8 = 248;
+export declare const LIST_16 = 249;
+export declare const JID_PAIR = 250;
+export declare const HEX_8 = 251;
+export declare const BINARY_8 = 252;
+export declare const BINARY_20 = 253;
+export declare const BINARY_32 = 254;
+export declare const NIBBLE_8 = 255;
+export declare const NIBBLE_ALPHABET: readonly string[];
+export declare const HEX_ALPHABET: readonly string[];
+export declare const SINGLE_BYTE_TOKEN_MAP: ReadonlyMap<string, number>;
+export declare const DICTIONARY_TOKEN_MAPS: readonly ReadonlyMap<string, number>[];
+export declare const WAP_ENCODE_CONSTANTS: Readonly<{
+    LIST_EMPTY: 0;
+    LIST_8: 248;
+    LIST_16: 249;
+    JID_PAIR: 250;
+    HEX_8: 251;
+    BINARY_8: 252;
+    BINARY_20: 253;
+    BINARY_32: 254;
+    NIBBLE_8: 255;
+    DICTIONARY_0: 236;
+    DICTIONARY_3: 239;
+}>;
+export declare const WAP_DECODE_CONSTANTS: Readonly<{
+    LIST_EMPTY: 0;
+    LIST_8: 248;
+    LIST_16: 249;
+    JID_PAIR: 250;
+    JID_FB: 246;
+    JID_INTEROP: 245;
+    JID_U: 247;
+    HEX_8: 251;
+    BINARY_8: 252;
+    BINARY_20: 253;
+    BINARY_32: 254;
+    NIBBLE_8: 255;
+    DICTIONARY_0: 236;
+    DICTIONARY_3: 239;
+    STREAM_END: 2;
+}>;

package/dist/types/transport/binary/decoder.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryNode } from '../types';
+export declare function decodeBinaryNode(data: Uint8Array): BinaryNode;
+export declare function decodeBinaryNodeStanza(stanza: Uint8Array): Promise<BinaryNode>;

package/dist/types/transport/binary/encoder.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryNode } from '../types';
+export declare function encodeBinaryNode(node: BinaryNode): Uint8Array;
+export declare function encodeBinaryNodeStanza(node: BinaryNode): Uint8Array;

package/dist/types/transport/binary/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../binary/tokens';
+export * from '../binary/encoder';
+export * from '../binary/decoder';
+export { WAP_DECODE_CONSTANTS as WapDecodeConstants, WAP_ENCODE_CONSTANTS as WapEncodeConstants } from '../binary/constants';

package/dist/types/transport/binary/tokens.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WhatsApp WAP dictionary tokens (dict version 3).
+ * Source: WAWeb deobfuscated WAWapDict.js
+ */
+export declare const DICT_VERSION = 3;
+export declare const SINGLE_BYTE_TOKENS: readonly string[];
+export declare const DICTIONARY_0_TOKENS: readonly string[];
+export declare const DICTIONARY_1_TOKENS: readonly string[];
+export declare const DICTIONARY_2_TOKENS: readonly string[];
+export declare const DICTIONARY_3_TOKENS: readonly string[];
+export declare const DICTIONARIES: readonly (readonly string[])[];

package/dist/types/transport/index.d.ts

@@ -0,0 +1,7 @@
+export type { BinaryNode, RawWebSocket, RawWebSocketConstructor, SocketCloseInfo, SocketOpenInfo, WaCommsConfig, WaCommsState, WaNoiseConfig, WaSocketConfig, WaSocketHandlers } from './types';
+export { WaComms } from './WaComms';
+export { WaWebSocket } from './WaWebSocket';
+export { WaKeepAlive } from './keepalive/WaKeepAlive';
+export { WaNodeOrchestrator } from './node/WaNodeOrchestrator';
+export { WaNodeTransport } from './node/WaNodeTransport';
+export { assertIqResult, buildIqNode, parseIqError, queryWithContext } from './node/query';

package/dist/types/transport/keepalive/WaKeepAlive.d.ts

@@ -0,0 +1,39 @@
+import type { Logger } from '../../infra/log/types';
+import type { BinaryNode } from '../types';
+import type { WaComms } from '../WaComms';
+interface WaKeepAliveOptions {
+    readonly logger: Logger;
+    readonly nodeOrchestrator: {
+        hasPending(): boolean;
+        query(node: BinaryNode, timeoutMs?: number): Promise<BinaryNode>;
+    };
+    readonly getComms: () => WaComms | null;
+    readonly intervalMs?: number;
+    readonly timeoutMs?: number;
+    readonly hostDomain?: string;
+    readonly jitterRatio?: number;
+    readonly minJitterMs?: number;
+}
+export declare class WaKeepAlive {
+    private readonly logger;
+    private readonly nodeOrchestrator;
+    private readonly getCommsFn;
+    private readonly intervalMs;
+    private readonly timeoutMs;
+    private readonly hostDomain;
+    private readonly jitterRatio;
+    private readonly minJitterMs;
+    private timer;
+    private generation;
+    private inFlight;
+    constructor(options: WaKeepAliveOptions);
+    start(): void;
+    stop(): void;
+    private schedule;
+    private run;
+    private normalizeJitterRatio;
+    private normalizeMinJitterMs;
+    private computeNextDelayMs;
+    private clearTimer;
+}
+export {};

package/dist/types/transport/node/WaNodeOrchestrator.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from '../../infra/log/types';
+import type { BinaryNode } from '../types';
+interface WaNodeOrchestratorOptions {
+    readonly logger: Logger;
+    readonly sendNode: (node: BinaryNode) => Promise<void>;
+    readonly defaultTimeoutMs?: number;
+    readonly hostDomain?: string;
+}
+export declare class WaNodeOrchestrator {
+    private readonly logger;
+    private readonly sendNodeFn;
+    private readonly defaultTimeoutMs;
+    private readonly hostDomain;
+    private stanzaPrefix;
+    private stanzaCounter;
+    private readonly pendingQueries;
+    constructor(options: WaNodeOrchestratorOptions);
+    hasPending(): boolean;
+    clearPending(reason: Error): void;
+    tryResolvePending(node: BinaryNode): boolean;
+    handleIncomingNode(node: BinaryNode): Promise<boolean>;
+    sendNode(node: BinaryNode): Promise<void>;
+    query(node: BinaryNode, timeoutMs?: number): Promise<BinaryNode>;
+    private withAutoId;
+    private getStanzaPrefix;
+    private generateStanzaPrefix;
+}
+export {};

package/dist/types/transport/node/WaNodeTransport.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from 'node:events';
+import type { Logger } from '../../infra/log/types';
+import type { BinaryNode } from '../types';
+import type { WaComms } from '../WaComms';
+interface NodeTransportEventMap {
+    readonly frame_in: (frame: Uint8Array) => void;
+    readonly frame_out: (frame: Uint8Array) => void;
+    readonly node_in: (node: BinaryNode, frame: Uint8Array) => void;
+    readonly node_out: (node: BinaryNode, frame: Uint8Array) => void;
+    readonly decode_error: (error: Error, frame: Uint8Array) => void;
+}
+export declare class WaNodeTransport extends EventEmitter {
+    private readonly logger;
+    private comms;
+    constructor(logger?: Logger);
+    on<K extends keyof NodeTransportEventMap>(event: K, listener: NodeTransportEventMap[K]): this;
+    bindComms(comms: WaComms | null): void;
+    sendNode(node: BinaryNode): Promise<void>;
+    dispatchIncomingFrame(frame: Uint8Array, onNode: (node: BinaryNode) => Promise<void> | void): Promise<void>;
+    private shouldIncludeTraceXml;
+}
+export {};

package/dist/types/transport/node/builders/accountSync.d.ts

@@ -0,0 +1,11 @@
+import type { BinaryNode } from '../../types';
+export declare function buildAccountDevicesSyncIq(userJids: readonly string[], sid: string): BinaryNode;
+export declare function buildAccountPictureSyncIq(meJid: string): BinaryNode;
+export declare function buildAccountPrivacySyncIq(): BinaryNode;
+export declare function buildAccountBlocklistSyncIq(): BinaryNode;
+export declare function buildGroupsDirtySyncIq(): BinaryNode;
+export declare function buildNewsletterMetadataSyncIq(): BinaryNode;
+export declare function buildClearDirtyBitsIq(dirtyBits: readonly {
+    readonly type: string;
+    readonly timestamp: number;
+}[]): BinaryNode;

package/dist/types/transport/node/builders/group.d.ts

@@ -0,0 +1,16 @@
+import type { BinaryNode } from '../../types';
+interface BuildCreateGroupIqInput {
+    readonly subject: string;
+    readonly participants: readonly string[];
+    readonly description?: string;
+}
+export declare function buildCreateGroupIq(input: BuildCreateGroupIqInput): BinaryNode;
+type GroupParticipantAction = 'add' | 'remove' | 'promote' | 'demote';
+interface BuildGroupParticipantChangeIqInput {
+    readonly groupJid: string;
+    readonly action: GroupParticipantAction;
+    readonly participants: readonly string[];
+}
+export declare function buildGroupParticipantChangeIq(input: BuildGroupParticipantChangeIqInput): BinaryNode;
+export declare function buildLeaveGroupIq(groupJids: readonly string[]): BinaryNode;
+export {};

package/dist/types/transport/node/builders/index.d.ts

@@ -0,0 +1,7 @@
+export { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../../node/builders/accountSync';
+export { buildCompanionFinishRequestNode, buildCompanionHelloRequestNode, buildGetCountryCodeRequestNode, buildIqResultNode, buildNotificationAckNode } from '../../node/builders/pairing';
+export { buildMediaConnIq } from '../../node/builders/media';
+export { buildDirectMessageFanoutNode, buildGroupDirectMessageNode, buildGroupRetryMessageNode, buildGroupSenderKeyMessageNode, buildInboundDeliveryReceiptNode, buildInboundMessageAckNode, buildInboundReceiptAckNode, buildInboundRetryReceiptNode, buildInboundRetryReceiptAckNode } from '../../node/builders/message';
+export { buildRetryReceiptNode } from '../../node/builders/retry';
+export { buildMissingPreKeysFetchIq, buildPreKeyUploadIq, buildSignedPreKeyRotateIq } from '../../node/builders/prekeys';
+export { buildCreateGroupIq, buildGroupParticipantChangeIq, buildLeaveGroupIq } from '../../node/builders/group';

package/dist/types/transport/node/builders/media.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryNode } from '../../types';
+export declare function buildMediaConnIq(): BinaryNode;

package/dist/types/transport/node/builders/message.d.ts

@@ -0,0 +1,52 @@
+import type { BinaryNode } from '../../types';
+interface EncryptedParticipant {
+    readonly jid: string;
+    readonly encType: 'msg' | 'pkmsg';
+    readonly ciphertext: Uint8Array;
+}
+interface BuildDirectMessageFanoutNodeInput {
+    readonly to: string;
+    readonly type: string;
+    readonly id?: string;
+    readonly participants: readonly EncryptedParticipant[];
+    readonly deviceIdentity?: Uint8Array;
+}
+interface BuildGroupSenderKeyMessageNodeInput {
+    readonly to: string;
+    readonly type: string;
+    readonly groupCiphertext: Uint8Array;
+    readonly id?: string;
+    readonly phash?: string;
+    readonly addressingMode?: 'pn' | 'lid';
+    readonly participants: readonly EncryptedParticipant[];
+    readonly deviceIdentity?: Uint8Array;
+}
+interface BuildGroupDirectMessageNodeInput {
+    readonly to: string;
+    readonly type: string;
+    readonly id?: string;
+    readonly phash?: string;
+    readonly addressingMode?: 'pn' | 'lid';
+    readonly participants: readonly EncryptedParticipant[];
+    readonly deviceIdentity?: Uint8Array;
+}
+interface BuildGroupRetryMessageNodeInput {
+    readonly to: string;
+    readonly type: string;
+    readonly id: string;
+    readonly requesterJid: string;
+    readonly addressingMode: 'pn' | 'lid';
+    readonly encType: 'msg' | 'pkmsg';
+    readonly ciphertext: Uint8Array;
+    readonly deviceIdentity?: Uint8Array;
+}
+export declare function buildDirectMessageFanoutNode(input: BuildDirectMessageFanoutNodeInput): BinaryNode;
+export declare function buildGroupSenderKeyMessageNode(input: BuildGroupSenderKeyMessageNodeInput): BinaryNode;
+export declare function buildGroupDirectMessageNode(input: BuildGroupDirectMessageNodeInput): BinaryNode;
+export declare function buildInboundMessageAckNode(messageNode: BinaryNode, id: string, to: string, meJid: string | null | undefined): BinaryNode;
+export declare function buildInboundDeliveryReceiptNode(messageNode: BinaryNode, id: string, to: string): BinaryNode;
+export declare function buildInboundRetryReceiptNode(messageNode: BinaryNode, id: string, to: string, meJid?: string | null, retryCount?: number): BinaryNode;
+export declare function buildInboundRetryReceiptAckNode(receiptNode: BinaryNode): BinaryNode;
+export declare function buildInboundReceiptAckNode(receiptNode: BinaryNode): BinaryNode;
+export declare function buildGroupRetryMessageNode(input: BuildGroupRetryMessageNodeInput): BinaryNode;
+export {};

package/dist/types/transport/node/builders/pairing.d.ts

@@ -0,0 +1,18 @@
+import type { BinaryNode } from '../../types';
+export declare function buildCompanionHelloRequestNode(args: {
+    readonly phoneJid: string;
+    readonly shouldShowPushNotification: boolean;
+    readonly wrappedCompanionEphemeralPub: Uint8Array;
+    readonly companionServerAuthKeyPub: Uint8Array;
+    readonly companionPlatformId: string;
+    readonly companionPlatformDisplay: string;
+}): BinaryNode;
+export declare function buildGetCountryCodeRequestNode(): BinaryNode;
+export declare function buildCompanionFinishRequestNode(args: {
+    readonly phoneJid: string;
+    readonly wrappedKeyBundle: Uint8Array;
+    readonly companionIdentityPublic: Uint8Array;
+    readonly ref: Uint8Array;
+}): BinaryNode;
+export declare function buildNotificationAckNode(node: BinaryNode, typeOverride?: string): BinaryNode;
+export declare function buildIqResultNode(iqNode: BinaryNode): BinaryNode;

package/dist/types/transport/node/builders/prekeys.d.ts

@@ -0,0 +1,5 @@
+import type { SignalMissingPreKeysTarget } from '../../../signal/api/SignalMissingPreKeysSyncApi';
+import type { PreKeyRecord, RegistrationInfo, SignedPreKeyRecord } from '../../../signal/types';
+export declare function buildPreKeyUploadIq(registrationInfo: RegistrationInfo, signedPreKey: SignedPreKeyRecord, preKeys: readonly PreKeyRecord[]): import("../..").BinaryNode;
+export declare function buildSignedPreKeyRotateIq(signedPreKey: SignedPreKeyRecord): import("../..").BinaryNode;
+export declare function buildMissingPreKeysFetchIq(users: readonly SignalMissingPreKeysTarget[]): import("../..").BinaryNode;

package/dist/types/transport/node/builders/retry.d.ts

@@ -0,0 +1,18 @@
+import type { WaRetryKeyBundle } from '../../../retry/types';
+import type { BinaryNode } from '../../types';
+interface BuildRetryReceiptNodeInput {
+    readonly stanzaId: string;
+    readonly to: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+    readonly from?: string;
+    readonly originalMsgId: string;
+    readonly retryCount: number;
+    readonly t: string;
+    readonly registrationId: number;
+    readonly error?: number;
+    readonly categoryPeer?: boolean;
+    readonly keys?: WaRetryKeyBundle;
+}
+export declare function buildRetryReceiptNode(input: BuildRetryReceiptNodeInput): BinaryNode;
+export {};

package/dist/types/transport/node/helpers.d.ts

@@ -0,0 +1,8 @@
+import type { BinaryNode } from '../types';
+export declare function getNodeChildren(node: BinaryNode): readonly BinaryNode[];
+export declare function findNodeChild(node: BinaryNode, tag: string): BinaryNode | undefined;
+export declare function getFirstNodeChild(node: BinaryNode): BinaryNode | undefined;
+export declare function getNodeChildrenByTag(node: BinaryNode, tag: string): readonly BinaryNode[];
+export declare function hasNodeChild(node: BinaryNode, tag: string): boolean;
+export declare function decodeNodeContentUtf8OrBytes(value: BinaryNode['content'], field: string): Uint8Array;
+export declare function decodeNodeContentBase64OrBytes(value: BinaryNode['content'], field: string): Uint8Array;

package/dist/types/transport/node/query.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from '../../infra/log/types';
+import type { BinaryNode } from '../types';
+export declare function buildIqNode(type: 'get' | 'set', to: string, xmlns: string, content?: BinaryNode['content'], attrs?: Readonly<Record<string, string>>): BinaryNode;
+export declare function parseIqError(node: BinaryNode): {
+    readonly code: string;
+    readonly text: string;
+    readonly numericCode?: number;
+};
+export declare function assertIqResult(node: BinaryNode, context: string): void;
+export declare function queryWithContext(query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>, logger: Logger, context: string, node: BinaryNode, timeoutMs: number, contextData?: Readonly<Record<string, unknown>>): Promise<BinaryNode>;

package/dist/types/transport/node/xml.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryNode } from '../types';
+export declare function formatBinaryNodeAsXml(node: BinaryNode): string;

package/dist/types/transport/noise/WaClientPayload.d.ts

@@ -0,0 +1,3 @@
+import type { WaLoginPayloadConfig, WaRegistrationPayloadConfig } from '../noise/types';
+export declare function buildLoginPayload(config: WaLoginPayloadConfig): Uint8Array;
+export declare function buildRegistrationPayload(config: WaRegistrationPayloadConfig): Uint8Array;

package/dist/types/transport/noise/WaFrameCodec.d.ts

@@ -0,0 +1,9 @@
+export declare class WaFrameCodec {
+    private readonly introFrame;
+    private readonly maxFrameLength;
+    private introSent;
+    private buffered;
+    constructor(introFrame?: Uint8Array, maxFrameLength?: number);
+    encodeFrame(frame: Uint8Array): Uint8Array;
+    pushWireChunk(chunk: Uint8Array): readonly Uint8Array[];
+}

package/dist/types/transport/noise/WaNoiseCert.d.ts

@@ -0,0 +1 @@
+export declare function verifyNoiseCertificateChain(certificateChain: Uint8Array, serverStatic: Uint8Array): Promise<void>;

package/dist/types/transport/noise/WaNoiseHandshake.d.ts

@@ -0,0 +1,14 @@
+import { WaNoiseSocket } from '../noise/WaNoiseSocket';
+export declare class WaNoiseHandshake {
+    private handshakeHash;
+    private chainingKey;
+    private cipherKey;
+    private nonce;
+    constructor();
+    start(protocolName: Uint8Array, prologue: Uint8Array): Promise<void>;
+    authenticate(data: Uint8Array): Promise<void>;
+    mixIntoKey(keyMaterial: Uint8Array): Promise<void>;
+    encrypt(plaintext: Uint8Array): Promise<Uint8Array>;
+    decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
+    finish(): Promise<WaNoiseSocket>;
+}

package/dist/types/transport/noise/WaNoiseSession.d.ts

@@ -0,0 +1,33 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaNoiseConfig } from '../types';
+export declare class WaNoiseSession {
+    private readonly sendWire;
+    private readonly logger;
+    private readonly writeQueue;
+    private readonly readQueue;
+    private frameCodec;
+    private handshakeInbox;
+    private handshakeWaiter;
+    private handshakeRejecter;
+    private pendingDecryptedFrames;
+    private closedError;
+    private noiseSocket;
+    private serverStaticKey;
+    private readonly handshakeFrameTimeoutMs;
+    constructor(sendWire: (payload: Uint8Array) => Promise<void>, logger?: Logger);
+    start(config: WaNoiseConfig): Promise<void>;
+    encryptFrame(frame: Uint8Array): Promise<Uint8Array>;
+    pushWireChunk(chunk: Uint8Array): Promise<readonly Uint8Array[]>;
+    onSocketClosed(error?: Error): void;
+    reset(): void;
+    getServerStaticKey(): Uint8Array | null;
+    private fullHandshake;
+    private resumeHandshake;
+    private tryResumeHandshakeWithIk;
+    private resumeHandshakeWithFallback;
+    private continueFullHandshake;
+    private sendHandshakeFrame;
+    private sendAndReceiveHandshakeFrame;
+    private waitHandshakeFrame;
+    private decodeBufferedPostHandshakeFrames;
+}

package/dist/types/transport/noise/WaNoiseSocket.d.ts

@@ -0,0 +1,10 @@
+import { type CryptoKey } from '@crypto';
+export declare class WaNoiseSocket {
+    private readonly encryptKey;
+    private readonly decryptKey;
+    private writeCounter;
+    private readCounter;
+    constructor(encryptKey: CryptoKey, decryptKey: CryptoKey);
+    encrypt(frame: Uint8Array, additionalData?: Uint8Array): Promise<Uint8Array>;
+    decrypt(frame: Uint8Array, additionalData?: Uint8Array): Promise<Uint8Array>;
+}

package/dist/types/transport/noise/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_VERSION_BASE = "2.3000.1034748654";
+export declare const WA_PROTO_HEADER: Uint8Array<ArrayBuffer>;
+export declare const NOISE_XX_NAME: NodeJS.NonSharedUint8Array;
+export declare const NOISE_IK_NAME: NodeJS.NonSharedUint8Array;
+export declare const NOISE_XX_FALLBACK_NAME: NodeJS.NonSharedUint8Array;
+export declare const ROOT_CA_SERIAL = 0;
+export declare const ROOT_CA_PUBLIC_KEY_HEX = "142375574d0a587166aae71ebe516437c4a28b73e3695c6ce1f7f9545da8ee6b";

package/dist/types/transport/noise/types.d.ts

@@ -0,0 +1,23 @@
+import type { Proto } from '../..';
+import type { RegistrationInfo, SignedPreKeyRecord } from '../../signal/types';
+export interface WaPayloadCommonConfig {
+    readonly passive?: boolean;
+    readonly pull?: boolean;
+    readonly versionBase?: string;
+    readonly deviceBrowser?: string;
+    readonly deviceOsDisplayName?: string;
+    readonly userAgent?: typeof Proto.ClientPayload.prototype.userAgent;
+    readonly webInfo?: typeof Proto.ClientPayload.prototype.webInfo;
+}
+export interface WaLoginPayloadConfig extends WaPayloadCommonConfig {
+    readonly username: number;
+    readonly device?: number;
+    readonly lidDbMigrated?: boolean;
+}
+export interface WaRegistrationPayloadConfig extends WaPayloadCommonConfig {
+    readonly registrationInfo: RegistrationInfo;
+    readonly signedPreKey: SignedPreKeyRecord;
+    readonly buildHash?: Uint8Array;
+    readonly deviceProps?: Uint8Array;
+    readonly requireFullSync?: boolean;
+}

package/dist/types/transport/stream/parse.d.ts

@@ -0,0 +1,23 @@
+import type { WaSuccessPersistAttributes } from '../../auth/types';
+import type { BinaryNode } from '../types';
+export type WaStreamControlNodeResult = {
+    readonly kind: 'xmlstreamend';
+} | {
+    readonly kind: 'stream_error_code';
+    readonly code: number;
+} | {
+    readonly kind: 'stream_error_replaced';
+} | {
+    readonly kind: 'stream_error_device_removed';
+} | {
+    readonly kind: 'stream_error_ack';
+    readonly id?: string;
+} | {
+    readonly kind: 'stream_error_xml_not_well_formed';
+} | {
+    readonly kind: 'stream_error_other';
+};
+export declare function parseStreamControlNode(node: BinaryNode): WaStreamControlNodeResult | null;
+export declare function parseOptionalInt(value: string | undefined): number | undefined;
+export declare function parseCompanionEncStatic(value: string | undefined, onError?: (error: Error) => void): Uint8Array | undefined;
+export declare function parseSuccessPersistAttributes(node: BinaryNode, onCompanionParseError?: (error: Error) => void): WaSuccessPersistAttributes;

package/dist/types/transport/types.d.ts

@@ -0,0 +1,71 @@
+import type { SignalKeyPair } from '../crypto/curves/types';
+import type { WaLoginPayloadConfig, WaRegistrationPayloadConfig } from './noise/types';
+export interface BinaryNode {
+    readonly tag: string;
+    readonly attrs: Readonly<Record<string, string>>;
+    readonly content?: Uint8Array | string | readonly BinaryNode[];
+}
+export interface SocketOpenInfo {
+    readonly openedAt: number;
+}
+export interface SocketCloseInfo {
+    readonly code: number;
+    readonly reason: string;
+    readonly wasClean: boolean;
+}
+export interface WaSocketConfig {
+    readonly url?: string;
+    readonly urls?: readonly string[];
+    readonly protocols?: readonly string[];
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly timeoutIntervalMs?: number;
+}
+export interface WaSocketHandlers {
+    readonly onOpen?: (info: SocketOpenInfo) => void | Promise<void>;
+    readonly onClose?: (info: SocketCloseInfo) => void | Promise<void>;
+    readonly onError?: (error: Error) => void | Promise<void>;
+    readonly onMessage?: (payload: Uint8Array) => void | Promise<void>;
+}
+export interface WaCommsConfig extends WaSocketConfig {
+    readonly connectTimeoutMs?: number;
+    readonly reconnectIntervalMs?: number;
+    readonly maxReconnectAttempts?: number;
+    readonly noise: WaNoiseConfig;
+}
+export interface WaCommsState {
+    readonly started: boolean;
+    readonly connected: boolean;
+    readonly handlingRequests: boolean;
+    readonly reconnectAttempts: number;
+}
+export interface WaNoiseConfig {
+    readonly clientStaticKeyPair: SignalKeyPair;
+    readonly isRegistered: boolean;
+    readonly loginPayload?: Uint8Array | (() => Uint8Array | Promise<Uint8Array>);
+    readonly registrationPayload?: Uint8Array | (() => Uint8Array | Promise<Uint8Array>);
+    readonly loginPayloadConfig?: WaLoginPayloadConfig;
+    readonly registrationPayloadConfig?: WaRegistrationPayloadConfig;
+    readonly serverStaticKey?: Uint8Array;
+    readonly routingInfo?: Uint8Array;
+    readonly protocolHeader?: Uint8Array;
+    readonly verifyCertificateChain?: boolean;
+}
+export interface WebSocketEventLike {
+    readonly code?: number;
+    readonly reason?: string;
+    readonly wasClean?: boolean;
+    readonly data?: unknown;
+}
+export interface RawWebSocket {
+    binaryType: string;
+    readyState: number;
+    onopen: ((event: WebSocketEventLike) => void) | null;
+    onclose: ((event: WebSocketEventLike) => void) | null;
+    onerror: ((event: WebSocketEventLike) => void) | null;
+    onmessage: ((event: WebSocketEventLike) => void) | null;
+    close(code?: number, reason?: string): void;
+    send(data: string | ArrayBuffer | Uint8Array): void;
+}
+export type RawWebSocketConstructor = new (url: string, protocols?: string | readonly string[], options?: {
+    headers?: Readonly<Record<string, string>>;
+}) => RawWebSocket;

package/dist/types/util/async.d.ts

@@ -0,0 +1 @@
+export declare function delay(ms: number): Promise<void>;

package/dist/types/util/base64.d.ts

@@ -0,0 +1,4 @@
+import { bytesToBase64, bytesToBase64UrlSafe } from './bytes';
+export { bytesToBase64, bytesToBase64UrlSafe };
+export declare function base64ToBytes(value: string, field: string, requireNonEmpty?: boolean): Uint8Array;
+export declare function decodeProtoBytes(value: Uint8Array | string | null | undefined, field: string): Uint8Array;

package/dist/types/util/bytes.d.ts

@@ -0,0 +1,28 @@
+import type { Readable } from 'node:stream';
+export declare const TEXT_ENCODER: import("../util").TextEncoder;
+export declare const TEXT_DECODER: import("../util").TextDecoder;
+export declare const EMPTY_BYTES: Readonly<Uint8Array<ArrayBuffer>>;
+/**
+ * Encodes a Uint8Array to a hex string
+ */
+export declare function bytesToHex(value: Uint8Array): string;
+/**
+ * Decodes a hex string to a Uint8Array
+ */
+export declare function hexToBytes(value: string): Uint8Array;
+export declare function bytesToBase64(value: Uint8Array): string;
+export declare function base64ToBytes(value: string): Uint8Array;
+/**
+ * Encodes a Uint8Array to a base64url string (URL-safe, no padding)
+ */
+export declare function bytesToBase64UrlSafe(value: Uint8Array): string;
+export declare function concatBytes(parts: readonly Uint8Array[]): Uint8Array;
+export declare function toBytesView(value: Uint8Array | ArrayBuffer | ArrayBufferView): Uint8Array;
+export declare function toChunkBytes(chunk: unknown): Uint8Array;
+export declare function uint8TimingSafeEqual(left: Uint8Array, right: Uint8Array): boolean;
+export declare function uint8Equal(a: Uint8Array, b: Uint8Array): boolean;
+export declare function removeAt<T>(items: readonly T[], index: number): T[];
+export declare function intToBytes(byteLength: number, value: number): Uint8Array;
+export declare function readAllBytes(stream: Readable, options?: {
+    readonly maxBytes?: number;
+}): Promise<Uint8Array>;

package/dist/types/util/coercion.d.ts

@@ -0,0 +1,8 @@
+export declare function asNumber(value: unknown, field: string): number;
+export declare function asOptionalNumber(value: unknown, field?: string): number | undefined;
+export declare function asString(value: unknown, field: string): string;
+export declare function asOptionalString(value: unknown, field?: string): string | undefined;
+export declare function asBytes(value: unknown, field: string): Uint8Array;
+export declare function asOptionalBytes(value: unknown, field?: string): Uint8Array | undefined;
+export declare function toBoolOrUndef(value: unknown): boolean | undefined;
+export declare function resolvePositive(value: number | undefined, fallback: number, name: string): number;

package/dist/types/util/collections.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveCleanupIntervalMs(ttlMs: number, maxIntervalMs?: number): number;
+export declare function normalizeQueryLimit(limit: number | undefined, defaultLimit: number): number;
+export declare function setBoundedMapEntry<K, V>(map: Map<K, V>, key: K, value: V, maxEntries: number, onEvict?: (key: K, value: V) => void): void;

package/dist/types/util/primitives.d.ts

@@ -0,0 +1,7 @@
+export declare function toError(value: unknown): Error;
+export declare function toSafeNumber(value: number | {
+    toNumber?: () => number;
+} | null | undefined, field: string): number;
+export declare function longToNumber(value: number | {
+    toNumber(): number;
+} | null | undefined): number;

package/dist/types/util/runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function getRuntimeOsDisplayName(): string;
+export declare function isBunRuntime(): boolean;

package/dist/types/util/signal-address.d.ts

@@ -0,0 +1,2 @@
+import type { SignalAddress } from '../signal/types';
+export declare function signalAddressKey(address: SignalAddress): string;

package/dist/util/async.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = delay;
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}