zapo-js 0.1.2 → 0.3.0

package/dist/types/store/types.d.ts

@@ -2,33 +2,36 @@ import type { WaAppStateStore } from './contracts/appstate.store';
 import type { WaAuthStore } from './contracts/auth.store';
 import type { WaContactStore } from './contracts/contact.store';
 import type { WaDeviceListStore } from './contracts/device-list.store';
+import type { WaIdentityStore } from './contracts/identity.store';
+import type { WaMessageSecretStore } from './contracts/message-secret.store';
 import type { WaMessageStore } from './contracts/message.store';
 import type { WaParticipantsStore } from './contracts/participants.store';
+import type { WaPreKeyStore } from './contracts/pre-key.store';
+import type { WaPrivacyTokenStore } from './contracts/privacy-token.store';
 import type { WaRetryStore } from './contracts/retry.store';
 import type { WaSenderKeyStore } from './contracts/sender-key.store';
+import type { WaSessionStore } from './contracts/session.store';
 import type { WaSignalStore } from './contracts/signal.store';
 import type { WaThreadStore } from './contracts/thread.store';
-export type WaSqliteDriver = 'auto' | 'better-sqlite3' | 'bun';
-export type WaSqliteTableName = 'wa_migrations' | 'auth_credentials' | 'signal_meta' | 'signal_registration' | 'signal_signed_prekey' | 'signal_prekey' | 'signal_session' | 'signal_identity' | 'sender_keys' | 'sender_key_distribution' | 'appstate_sync_keys' | 'appstate_collection_versions' | 'appstate_collection_index_values' | 'retry_outbound_messages' | 'retry_inbound_counters' | 'mailbox_messages' | 'mailbox_threads' | 'mailbox_contacts' | 'group_participants_cache' | 'device_list_cache';
-export type WaSqliteTableNameOverrides = Readonly<Partial<Record<WaSqliteTableName, string>>>;
-export interface WaSqliteStorageOptions {
-    readonly path: string;
-    readonly sessionId: string;
-    readonly driver?: WaSqliteDriver;
-    readonly pragmas?: Readonly<Record<string, string | number>>;
-    readonly tableNames?: WaSqliteTableNameOverrides;
-}
+export type WithDestroyLifecycle<T> = T & {
+    readonly destroy?: () => Promise<void>;
+};
 export interface WaStoreSession {
     readonly auth: WaAuthStore;
     readonly signal: WaSignalStore;
+    readonly preKey: WaPreKeyStore;
+    readonly session: WaSessionStore;
+    readonly identity: WaIdentityStore;
     readonly senderKey: WaSenderKeyStore;
     readonly appState: WaAppStateStore;
     readonly retry: WaRetryStore;
     readonly participants: WaParticipantsStore;
     readonly deviceList: WaDeviceListStore;
     readonly messages: WaMessageStore;
+    readonly messageSecret: WaMessageSecretStore;
     readonly threads: WaThreadStore;
     readonly contacts: WaContactStore;
+    readonly privacyToken: WaPrivacyTokenStore;
     destroyCaches(): Promise<void>;
     destroy(): Promise<void>;
 }
@@ -37,30 +40,59 @@ export interface WaStore {
     destroyCaches(): Promise<void>;
     destroy(): Promise<void>;
 }
-export interface WaStoreProviderSelection {
-    readonly auth?: 'sqlite';
-    readonly signal?: 'sqlite' | 'memory';
-    readonly senderKey?: 'sqlite' | 'memory';
-    readonly appState?: 'sqlite' | 'memory';
-    readonly messages?: 'none' | 'sqlite' | 'memory';
-    readonly threads?: 'none' | 'sqlite' | 'memory';
-    readonly contacts?: 'none' | 'sqlite' | 'memory';
-}
-export interface WaStoreCacheProviderSelection {
-    readonly retry?: 'sqlite' | 'memory';
-    readonly participants?: 'none' | 'sqlite' | 'memory';
-    readonly deviceList?: 'none' | 'sqlite' | 'memory';
-}
-export interface WaStoreCacheTtlSelection {
-    readonly retryMs?: number;
-    readonly participantsMs?: number;
-    readonly deviceListMs?: number;
+export interface WaStoreBackend {
+    readonly stores: {
+        readonly auth: (sessionId: string) => WaAuthStore;
+        readonly signal: (sessionId: string) => WaSignalStore;
+        readonly preKey: (sessionId: string) => WaPreKeyStore;
+        readonly session: (sessionId: string) => WaSessionStore;
+        readonly identity: (sessionId: string) => WaIdentityStore;
+        readonly senderKey: (sessionId: string) => WaSenderKeyStore;
+        readonly appState: (sessionId: string) => WaAppStateStore;
+        readonly messages: (sessionId: string) => WaMessageStore;
+        readonly threads: (sessionId: string) => WaThreadStore;
+        readonly contacts: (sessionId: string) => WaContactStore;
+        readonly privacyToken: (sessionId: string) => WaPrivacyTokenStore;
+    };
+    readonly caches: {
+        readonly retry: (sessionId: string) => WaRetryStore;
+        readonly participants: (sessionId: string) => WaParticipantsStore;
+        readonly deviceList: (sessionId: string) => WaDeviceListStore;
+        readonly messageSecret: (sessionId: string) => WaMessageSecretStore;
+    };
 }
-export interface WaStoreSqliteBatchSizeSelection {
-    readonly deviceList?: number;
-    readonly senderKeyDistribution?: number;
-    readonly signalPreKey?: number;
-    readonly signalHasSession?: number;
+export type WaStoreDomain = keyof WaStoreBackend['stores'];
+export type WaCacheDomain = keyof WaStoreBackend['caches'];
+export interface WaCreateStoreOptions<B extends string = string> {
+    readonly backends?: Readonly<Record<B, WaStoreBackend>>;
+    readonly providers?: {
+        readonly auth?: B | 'memory';
+        readonly signal?: B | 'memory';
+        readonly preKey?: B | 'memory';
+        readonly session?: B | 'memory';
+        readonly identity?: B | 'memory';
+        readonly senderKey?: B | 'memory';
+        readonly appState?: B | 'memory';
+        readonly messages?: B | 'memory' | 'none';
+        readonly threads?: B | 'memory' | 'none';
+        readonly contacts?: B | 'memory' | 'none';
+        readonly privacyToken?: B | 'memory';
+    };
+    readonly cacheProviders?: {
+        readonly retry?: B | 'memory' | 'none';
+        readonly participants?: B | 'memory' | 'none';
+        readonly deviceList?: B | 'memory' | 'none';
+        readonly messageSecret?: B | 'memory' | 'none';
+    };
+    readonly memory?: {
+        readonly limits?: WaStoreMemoryLimitSelection;
+        readonly cacheTtlMs?: {
+            readonly retryMs?: number;
+            readonly participantsMs?: number;
+            readonly deviceListMs?: number;
+            readonly messageSecretMs?: number;
+        };
+    };
 }
 export interface WaStoreMemoryLimitSelection {
     readonly appStateSyncKeys?: number;
@@ -73,34 +105,10 @@ export interface WaStoreMemoryLimitSelection {
     readonly participantsGroups?: number;
     readonly deviceListUsers?: number;
     readonly messages?: number;
+    readonly messageSecrets?: number;
+    readonly retryOutboundMessages?: number;
+    readonly retryInboundCounters?: number;
     readonly threads?: number;
     readonly contacts?: number;
-}
-export type WaStoreDomainValueOrFactory<T> = T | ((sessionId: string) => T);
-export interface WaCreateStoreCustomProviders {
-    readonly auth?: WaStoreDomainValueOrFactory<WaAuthStore>;
-    readonly signal?: WaStoreDomainValueOrFactory<WaSignalStore>;
-    readonly senderKey?: WaStoreDomainValueOrFactory<WaSenderKeyStore>;
-    readonly appState?: WaStoreDomainValueOrFactory<WaAppStateStore>;
-    readonly messages?: WaStoreDomainValueOrFactory<WaMessageStore>;
-    readonly threads?: WaStoreDomainValueOrFactory<WaThreadStore>;
-    readonly contacts?: WaStoreDomainValueOrFactory<WaContactStore>;
-}
-export interface WaCreateStoreCustomCacheProviders {
-    readonly retry?: WaStoreDomainValueOrFactory<WaRetryStore>;
-    readonly participants?: WaStoreDomainValueOrFactory<WaParticipantsStore>;
-    readonly deviceList?: WaStoreDomainValueOrFactory<WaDeviceListStore>;
-}
-export interface WaCreateStoreOptions {
-    readonly sqlite?: Omit<WaSqliteStorageOptions, 'sessionId'> & {
-        readonly batchSizes?: WaStoreSqliteBatchSizeSelection;
-    };
-    readonly memory?: {
-        readonly limits?: WaStoreMemoryLimitSelection;
-    };
-    readonly providers?: WaStoreProviderSelection;
-    readonly cacheProviders?: WaStoreCacheProviderSelection;
-    readonly cacheTtlMs?: WaStoreCacheTtlSelection;
-    readonly custom?: WaCreateStoreCustomProviders;
-    readonly customCache?: WaCreateStoreCustomCacheProviders;
+    readonly privacyTokens?: number;
 }

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

@@ -5,6 +5,7 @@ export declare class WaWebSocket {
     private readonly socketUrls;
     private readonly logger;
     private readonly webSocketCtor;
+    private readonly customWebSocketCtor;
     private readonly socketRuntime;
     private readonly connectingSockets;
     private handlers;
@@ -15,7 +16,6 @@ export declare class WaWebSocket {
     setHandlers(handlers: WaSocketHandlers): void;
     isOpen(): boolean;
     isConnecting(): boolean;
-    getReadyState(): number;
     open(): Promise<SocketOpenInfo>;
     close(code?: number, reason?: string): Promise<SocketCloseInfo | null>;
     send(data: string | ArrayBuffer | Uint8Array): Promise<void>;

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

@@ -17,33 +17,3 @@ 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/index.d.ts

@@ -1,4 +1,3 @@
 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/index.d.ts

@@ -1,8 +1,15 @@
-export type { BinaryNode, RawWebSocket, RawWebSocketConstructor, WaRawWebSocketInit, SocketCloseInfo, SocketOpenInfo, WaCommsConfig, WaCommsState, WaNoiseConfig, WaProxyAgent, WaProxyDispatcher, WaProxyTransport, WaSocketConfig, WaSocketHandlers } from './types';
+export type { BinaryNode, RawWebSocket, RawWebSocketConstructor, WaRawWebSocketInit, SocketCloseInfo, SocketOpenInfo, WaCommsConfig, WaCommsState, WaNoiseConfig, WaNoiseTrustedRootCa, WaProxyAgent, WaProxyDispatcher, WaProxyTransport, WaSocketConfig, WaSocketHandlers } from './types';
+export { decodeBinaryNode, decodeBinaryNodeStanza, encodeBinaryNode, encodeBinaryNodeStanza } from './binary';
 export { isProxyAgent, isProxyDispatcher, isProxyTransport, toProxyAgent, toProxyDispatcher } from './proxy';
 export { WaComms } from './WaComms';
+export { verifyNoiseCertificateChain, type WaNoiseRootCa } from './noise/WaNoiseCert';
+export { WaNoiseHandshake } from './noise/WaNoiseHandshake';
+export { WaNoiseSocket } from './noise/WaNoiseSocket';
 export { WaWebSocket } from './WaWebSocket';
 export { WaKeepAlive } from './keepalive/WaKeepAlive';
 export { WaNodeOrchestrator } from './node/WaNodeOrchestrator';
 export { WaNodeTransport } from './node/WaNodeTransport';
+export { WaMobileTcpSocket, WaMobileTcpSocketCtor } from './node/WaMobileTcpSocket';
+export { buildMobileLoginPayload } from './noise/WaMobileClientPayload';
+export type { WaMobileLoginPayloadConfig, WaMobileTransportDeviceInfo } from './noise/WaMobileClientPayload';
 export { assertIqResult, buildIqNode, parseIqError, queryWithContext } from './node/query';

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

@@ -9,6 +9,7 @@ interface WaKeepAliveOptions {
     };
     readonly getComms: () => WaComms | null;
     readonly intervalMs?: number;
+    readonly getIntervalMs?: () => number;
     readonly timeoutMs?: number;
     readonly hostDomain?: string;
     readonly jitterRatio?: number;
@@ -18,7 +19,8 @@ export declare class WaKeepAlive {
     private readonly logger;
     private readonly nodeOrchestrator;
     private readonly getCommsFn;
-    private readonly intervalMs;
+    private readonly baseIntervalMs;
+    private readonly getIntervalMs;
     private readonly timeoutMs;
     private readonly hostDomain;
     private readonly jitterRatio;
@@ -32,6 +34,7 @@ export declare class WaKeepAlive {
     private schedule;
     private run;
     private normalizeJitterRatio;
+    private resolveIntervalMs;
     private computeNextDelayMs;
     private clearTimer;
 }

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

@@ -0,0 +1,18 @@
+import type { RawWebSocket, RawWebSocketConstructor, WaRawWebSocketInit, WebSocketEventLike } from '../types';
+export declare class WaMobileTcpSocket implements 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;
+    private readonly socket;
+    private closedCode;
+    private closedReason;
+    private closedClean;
+    private forceCloseTimer;
+    constructor(url: string, _protocols?: unknown, _options?: WaRawWebSocketInit);
+    send(data: string | ArrayBuffer | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+}
+export declare const WaMobileTcpSocketCtor: RawWebSocketConstructor;

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

@@ -5,24 +5,27 @@ interface WaNodeOrchestratorOptions {
     readonly sendNode: (node: BinaryNode) => Promise<void>;
     readonly defaultTimeoutMs?: number;
     readonly hostDomain?: string;
+    readonly mobileIqIdFormat?: boolean;
 }
 export declare class WaNodeOrchestrator {
     private readonly logger;
     private readonly sendNodeFn;
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
-    private stanzaPrefix;
-    private stanzaCounter;
+    private readonly mobileIqIdFormat;
+    private idGenerator;
+    private idGeneratorReady;
     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>;
+    sendNode(node: BinaryNode, autoId?: boolean): Promise<void>;
+    query(node: BinaryNode, timeoutMs?: number, options?: {
+        readonly useSystemId?: boolean;
+    }): Promise<BinaryNode>;
     private withAutoId;
-    private getStanzaPrefix;
-    private generateStanzaPrefix;
+    private getIdGenerator;
 }
 export {};

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

@@ -0,0 +1,5 @@
+import type { BinaryNode } from '../../types';
+export declare function buildGetAbPropsIq(options?: {
+    readonly hash?: string | null;
+    readonly refreshId?: number | null;
+}): BinaryNode;

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

@@ -0,0 +1,29 @@
+import type { BinaryNode } from '../../types';
+export declare const WA_BUSINESS_PROFILE_VERSION = 116;
+export interface WaEditBusinessProfileInput {
+    readonly address?: string;
+    readonly description?: string;
+    readonly email?: string;
+    readonly websites?: readonly {
+        readonly url: string;
+    }[];
+    readonly categories?: readonly {
+        readonly id: string;
+    }[];
+    readonly businessHours?: {
+        readonly timezone?: string;
+        readonly config: readonly {
+            readonly dayOfWeek: string;
+            readonly mode: string;
+            readonly openTime?: number;
+            readonly closeTime?: number;
+        }[];
+    };
+    readonly latitude?: number;
+    readonly longitude?: number;
+}
+export declare function buildGetBusinessProfileIq(jids: readonly string[], version?: number): BinaryNode;
+export declare function buildEditBusinessProfileIq(input: WaEditBusinessProfileInput): BinaryNode;
+export declare function buildGetVerifiedNameIq(jid: string): BinaryNode;
+export declare function buildUpdateCoverPhotoIq(id: string, timestamp: string, token: string): BinaryNode;
+export declare function buildDeleteCoverPhotoIq(id: string): BinaryNode;

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

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

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

@@ -0,0 +1,11 @@
+import { type WaEmailContext } from '../../../protocol/email';
+import type { BinaryNode } from '../../types';
+export declare function buildGetEmailIq(): BinaryNode;
+export declare function buildSetEmailIq(email: string, context?: WaEmailContext): BinaryNode;
+export interface BuildRequestEmailVerificationCodeInput {
+    readonly languageCode: string;
+    readonly localeCode: string;
+}
+export declare function buildRequestEmailVerificationCodeIq(input: BuildRequestEmailVerificationCodeInput): BinaryNode;
+export declare function buildVerifyEmailCodeIq(code: string): BinaryNode;
+export declare function buildConfirmEmailIq(context?: WaEmailContext): BinaryNode;

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

@@ -0,0 +1,102 @@
+import type { BinaryNode } from '../../types';
+export type BuildAckNodeInput = {
+    readonly kind: 'notification';
+    readonly node: BinaryNode;
+    readonly typeOverride?: string;
+    readonly includeParticipant?: boolean;
+    readonly includeType?: boolean;
+    readonly content?: BinaryNode[];
+} | {
+    readonly kind: 'message';
+    readonly node: BinaryNode;
+    readonly id: string;
+    readonly to: string;
+    readonly from?: string | null;
+    readonly typeOverride?: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+} | {
+    readonly kind: 'receipt';
+    readonly node: BinaryNode;
+    readonly retryType?: boolean;
+    readonly typeOverride?: string;
+    readonly includeParticipant?: boolean;
+    readonly includeRecipient?: boolean;
+} | {
+    readonly kind: 'aggregate_message';
+    readonly to: string;
+    readonly ids: readonly string[];
+    readonly recipient?: string;
+    readonly participant?: string;
+    readonly type?: string;
+} | {
+    readonly kind: 'nack';
+    readonly stanzaTag: string;
+    readonly id: string;
+    readonly to: string;
+    readonly type?: string;
+    readonly participant?: string;
+    readonly error: number | string;
+    readonly failureReason?: number;
+} | {
+    readonly kind: 'custom';
+    readonly ackClass: string;
+    readonly to: string;
+    readonly id?: string;
+    readonly type?: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+    readonly from?: string;
+    readonly error?: number | string;
+    readonly content?: BinaryNode[];
+};
+export declare function buildAckNode(input: BuildAckNodeInput): BinaryNode;
+export type BuildReceiptNodeInput = {
+    readonly kind: 'delivery';
+    readonly node: BinaryNode;
+    readonly id: string;
+    readonly to: string;
+} | {
+    readonly kind: 'retry_custom';
+    readonly id: string;
+    readonly to: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+    readonly categoryPeer?: boolean;
+    readonly content: BinaryNode[];
+} | {
+    readonly kind: 'retry';
+    readonly node: BinaryNode;
+    readonly id: string;
+    readonly to: string;
+    readonly retryCount?: number;
+} | {
+    readonly kind: 'outbound';
+    readonly id: string;
+    readonly to: string;
+    readonly type?: string;
+    readonly participant?: string;
+    readonly recipient?: string;
+    readonly category?: string;
+    readonly from?: string;
+    readonly t?: string;
+    readonly peerParticipantPn?: string;
+    readonly listIds?: readonly string[];
+    readonly content?: BinaryNode[];
+} | {
+    readonly kind: 'server_error';
+    readonly id: string;
+    readonly to: string;
+    readonly categoryPeer?: boolean;
+    readonly encryptCiphertext: Uint8Array;
+    readonly encryptIv: Uint8Array;
+    readonly rmrJid?: string;
+    readonly rmrFromMe?: boolean | string;
+    readonly rmrParticipant?: string;
+} | {
+    readonly kind: 'custom';
+    readonly attrs: Readonly<Record<string, string>>;
+    readonly content?: BinaryNode[];
+};
+export declare function buildReceiptNode(input: BuildReceiptNodeInput): BinaryNode;
+export declare function buildIqResultNode(iqNode: BinaryNode): BinaryNode;

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

@@ -8,9 +8,13 @@ type DirectMessageFanoutInput = {
     readonly to: string;
     readonly type: string;
     readonly id?: string;
+    readonly edit?: string;
     readonly participants: readonly EncryptedParticipant[];
     readonly deviceIdentity?: Uint8Array;
     readonly reportingNode?: BinaryNode;
+    readonly privacyTokenNode?: BinaryNode;
+    readonly metaNode?: BinaryNode;
+    readonly mediatype?: string;
 };
 type GroupMessageFanoutInput = DirectMessageFanoutInput & {
     readonly phash?: string;
@@ -27,15 +31,12 @@ type GroupRetryMessageInput = {
     readonly addressingMode: 'pn' | 'lid';
     readonly encType: 'msg' | 'pkmsg';
     readonly ciphertext: Uint8Array;
+    readonly retryCount: number;
     readonly deviceIdentity?: Uint8Array;
+    readonly mediatype?: string;
 };
-export declare function buildDirectMessageFanoutNode(input: DirectMessageFanoutInput): BinaryNode;
+export declare function buildDirectMessageFanoutNode(input: GroupMessageFanoutInput): BinaryNode;
 export declare function buildGroupSenderKeyMessageNode(input: GroupSenderKeyMessageInput): BinaryNode;
-export declare function buildGroupDirectMessageNode(input: GroupMessageFanoutInput): 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: GroupRetryMessageInput): BinaryNode;
+export declare function buildMetaNode(attrs: Record<string, string>): BinaryNode;
 export {};

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

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

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

@@ -14,5 +14,3 @@ export declare function buildCompanionFinishRequestNode(args: {
     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

@@ -1,5 +1,6 @@
 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;
+import type { BinaryNode } from '../../types';
+export declare function buildPreKeyUploadIq(registrationInfo: RegistrationInfo, signedPreKey: SignedPreKeyRecord, preKeys: readonly PreKeyRecord[]): BinaryNode;
+export declare function buildSignedPreKeyRotateIq(signedPreKey: SignedPreKeyRecord): BinaryNode;
+export declare function buildMissingPreKeysFetchIq(users: readonly SignalMissingPreKeysTarget[]): BinaryNode;

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

@@ -0,0 +1,6 @@
+import type { BinaryNode } from '../../types';
+export interface BuildPresenceNodeInput {
+    readonly type?: 'available' | 'unavailable';
+    readonly name?: string;
+}
+export declare function buildPresenceNode(input?: BuildPresenceNodeInput): BinaryNode;

package/dist/types/transport/node/builders/privacy-token.d.ts

@@ -0,0 +1,9 @@
+import type { BinaryNode } from '../../types';
+export interface BuildPrivacyTokenIqInput {
+    readonly jid: string;
+    readonly timestampS: number;
+    readonly type?: string;
+}
+export declare function buildPrivacyTokenIqNode(input: BuildPrivacyTokenIqInput): BinaryNode;
+export declare function buildTcTokenMessageNode(token: Uint8Array): BinaryNode;
+export declare function buildCsTokenMessageNode(hash: Uint8Array): BinaryNode;

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

@@ -0,0 +1,7 @@
+import { type WaPrivacyCategory, type WaPrivacyValue } from '../../../protocol/privacy';
+import type { BinaryNode } from '../../types';
+export declare function buildGetPrivacySettingsIq(): BinaryNode;
+export declare function buildSetPrivacyCategoryIq(category: WaPrivacyCategory, value: WaPrivacyValue): BinaryNode;
+export declare function buildGetPrivacyDisallowedListIq(category: WaPrivacyCategory): BinaryNode;
+export declare function buildGetBlocklistIq(): BinaryNode;
+export declare function buildBlocklistChangeIq(jid: string, action: 'block' | 'unblock'): BinaryNode;

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

@@ -0,0 +1,8 @@
+import type { BinaryNode } from '../../types';
+export type WaProfilePictureType = 'preview' | 'image';
+export declare function buildGetProfilePictureIq(targetJid: string, type?: WaProfilePictureType, existingId?: string): BinaryNode;
+export declare function buildSetProfilePictureIq(imageBytes: Uint8Array, targetJid?: string): BinaryNode;
+export declare function buildDeleteProfilePictureIq(targetJid?: string): BinaryNode;
+export declare function buildSetStatusIq(text: string): BinaryNode;
+export declare function buildGetDisappearingModeUsyncQueryNode(): BinaryNode;
+export declare function buildGetStatusUsyncQueryNodes(): readonly BinaryNode[];

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

@@ -5,7 +5,6 @@ export declare function buildRetryReceiptNode(input: {
     readonly to: string;
     readonly participant?: string;
     readonly recipient?: string;
-    readonly from?: string;
     readonly originalMsgId: string;
     readonly retryCount: number;
     readonly t: string;

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

@@ -1,4 +1,9 @@
 import type { BinaryNode } from '../types';
+export interface NodeIdGenerator {
+    readonly prefix: string;
+    next(): string;
+    nextSystem?(): string;
+}
 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;
@@ -12,5 +17,8 @@ export declare function findNodeChildrenByTags<const TTags extends readonly stri
 };
 export declare function hasNodeChild(node: BinaryNode, tag: string): boolean;
 export declare function decodeNodeContentUtf8OrBytes(value: BinaryNode['content'], field: string): Uint8Array;
+export declare function getNodeTextContent(node: BinaryNode): string | undefined;
 export declare function decodeNodeContentBase64OrBytes(value: BinaryNode['content'], field: string): Uint8Array;
 export declare function formatNodeIdPrefixFromSeed(seed: Uint8Array): string;
+export declare function createNodeIdGenerator(): Promise<NodeIdGenerator>;
+export declare function createMobileNodeIdGenerator(): NodeIdGenerator;

package/dist/types/transport/node/mex/argo-decoder.d.ts

@@ -0,0 +1,11 @@
+export interface WaMexArgoError {
+    readonly message: string;
+    readonly path: number | null;
+    readonly extensions: Record<string, unknown> | null;
+}
+export interface WaMexArgoResponse {
+    readonly data: unknown;
+    readonly errors: WaMexArgoError[];
+}
+export declare function isMexArgoDecoderAvailable(): Promise<boolean>;
+export declare function decodeMexArgoResponse(bytes: Uint8Array): Promise<WaMexArgoResponse>;

package/dist/types/transport/node/mex/client.d.ts

@@ -0,0 +1,18 @@
+import type { BinaryNode } from '../../types';
+export interface WaMexQuerySocket {
+    readonly query: (node: BinaryNode, timeoutMs: number) => Promise<BinaryNode>;
+}
+export interface WaMexQueryArgs {
+    readonly docId: string;
+    readonly clientDocId: string;
+    /** Passed verbatim — caller wraps under `input` only when the op's schema requires it. */
+    readonly variables: Readonly<Record<string, unknown>>;
+    readonly opName: string;
+    readonly timeoutMs?: number;
+    readonly iqId?: string;
+}
+export interface WaMexResponse {
+    readonly raw: BinaryNode;
+    readonly data: unknown;
+}
+export declare function dispatchMexQuery(socket: WaMexQuerySocket, args: WaMexQueryArgs): Promise<WaMexResponse>;