zapo-js 0.2.0 → 0.3.0

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

@@ -1,10 +1,4 @@
-import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../signal/types';
-export interface WaSignalMetaSnapshot {
-    readonly serverHasPreKeys: boolean;
-    readonly signedPreKeyRotationTs: number | null;
-    readonly registrationInfo: RegistrationInfo | null;
-    readonly signedPreKey: SignedPreKeyRecord | null;
-}
+import type { RegistrationInfo, SignedPreKeyRecord } from '../../signal/types';
 export interface WaSignalStore {
     getRegistrationInfo(): Promise<RegistrationInfo | null>;
     setRegistrationInfo(info: RegistrationInfo): Promise<void>;
@@ -13,32 +7,5 @@ export interface WaSignalStore {
     getSignedPreKeyById(keyId: number): Promise<SignedPreKeyRecord | null>;
     setSignedPreKeyRotationTs(value: number | null): Promise<void>;
     getSignedPreKeyRotationTs(): Promise<number | null>;
-    putPreKey(record: PreKeyRecord): Promise<void>;
-    getOrGenPreKeys(count: number, generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<readonly PreKeyRecord[]>;
-    getPreKeyById(keyId: number): Promise<PreKeyRecord | null>;
-    getPreKeysById(keyIds: readonly number[]): Promise<readonly (PreKeyRecord | null)[]>;
-    consumePreKeyById(keyId: number): Promise<PreKeyRecord | null>;
-    getOrGenSinglePreKey(generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<PreKeyRecord>;
-    markKeyAsUploaded(keyId: number): Promise<void>;
-    setServerHasPreKeys(value: boolean): Promise<void>;
-    getServerHasPreKeys(): Promise<boolean>;
-    getSignalMeta(): Promise<WaSignalMetaSnapshot>;
-    hasSession(address: SignalAddress): Promise<boolean>;
-    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
-    getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
-    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
-    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
-    setSessionsBatch(entries: readonly {
-        readonly address: SignalAddress;
-        readonly session: SignalSessionRecord;
-    }[]): Promise<void>;
-    deleteSession(address: SignalAddress): Promise<void>;
-    getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
-    getRemoteIdentities(addresses: readonly SignalAddress[]): Promise<readonly (Uint8Array | null)[]>;
-    setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
-    setRemoteIdentities(entries: readonly {
-        readonly address: SignalAddress;
-        readonly identityKey: Uint8Array;
-    }[]): Promise<void>;
     clear(): Promise<void>;
 }

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

@@ -3,21 +3,29 @@ export { createStore } from './createStore';
 export type { WaAuthStore } from './contracts/auth.store';
 export type { WaContactStore, WaStoredContactRecord } from './contracts/contact.store';
 export type { WaDeviceListSnapshot, WaDeviceListStore } from './contracts/device-list.store';
+export type { WaMessageSecretEntry, WaMessageSecretStore } from './contracts/message-secret.store';
 export type { WaMessageStore, WaStoredMessageRecord } from './contracts/message.store';
 export type { WaParticipantsSnapshot, WaParticipantsStore } from './contracts/participants.store';
 export type { WaAppStateCollectionStateUpdate, WaAppStateCollectionStoreState, WaAppStateStore } from './contracts/appstate.store';
+export type { WaIdentityStore } from './contracts/identity.store';
+export type { WaPreKeyStore } from './contracts/pre-key.store';
 export type { WaSenderKeyStore } from './contracts/sender-key.store';
-export type { WaSignalMetaSnapshot, WaSignalStore } from './contracts/signal.store';
+export type { WaSessionStore } from './contracts/session.store';
+export type { WaSignalStore } from './contracts/signal.store';
 export type { WaRetryStore } from './contracts/retry.store';
 export type { WaStoredThreadRecord, WaThreadStore } from './contracts/thread.store';
 export type { WaPrivacyTokenStore, WaStoredPrivacyTokenRecord } from './contracts/privacy-token.store';
 export { WaAppStateMemoryStore } from './providers/memory/appstate.store';
 export { WaSignalMemoryStore } from './providers/memory/signal.store';
+export { WaPreKeyMemoryStore } from './providers/memory/pre-key.store';
+export { WaSessionMemoryStore } from './providers/memory/session.store';
+export { WaIdentityMemoryStore } from './providers/memory/identity.store';
 export { SenderKeyMemoryStore } from './providers/memory/sender-key.store';
 export { WaRetryMemoryStore } from './providers/memory/retry.store';
 export { WaParticipantsMemoryStore } from './providers/memory/participants.store';
 export { WaDeviceListMemoryStore } from './providers/memory/device-list.store';
 export { WaContactMemoryStore } from './providers/memory/contact.store';
+export { WaMessageSecretMemoryStore } from './providers/memory/message-secret.store';
 export { WaMessageMemoryStore } from './providers/memory/message.store';
 export { WaThreadMemoryStore } from './providers/memory/thread.store';
 export { WaPrivacyTokenMemoryStore } from './providers/memory/privacy-token.store';

package/dist/types/store/locks/identity.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaIdentityStore } from '../contracts/identity.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withIdentityLock(store: WaIdentityStore): WithDestroyLifecycle<WaIdentityStore>;

package/dist/types/store/locks/message-secret.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaMessageSecretStore } from '../contracts/message-secret.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withMessageSecretLock(store: WaMessageSecretStore): WithDestroyLifecycle<WaMessageSecretStore>;

package/dist/types/store/locks/pre-key.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaPreKeyStore } from '../contracts/pre-key.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withPreKeyLock(store: WaPreKeyStore): WithDestroyLifecycle<WaPreKeyStore>;

package/dist/types/store/locks/session.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaSessionStore } from '../contracts/session.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withSessionLock(store: WaSessionStore): WithDestroyLifecycle<WaSessionStore>;

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

@@ -1,10 +1,14 @@
 import type { WaContactStore } from './contracts/contact.store';
 import type { WaDeviceListStore } from './contracts/device-list.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 { WaRetryStore } from './contracts/retry.store';
 import type { WaThreadStore } from './contracts/thread.store';
+export declare const NOOP_MESSAGE_SECRET_STORE: WaMessageSecretStore;
 export declare const NOOP_MESSAGE_STORE: WaMessageStore;
 export declare const NOOP_THREAD_STORE: WaThreadStore;
 export declare const NOOP_CONTACT_STORE: WaContactStore;
+export declare const NOOP_RETRY_STORE: WaRetryStore;
 export declare const NOOP_PARTICIPANTS_STORE: WaParticipantsStore;
 export declare const NOOP_DEVICE_LIST_STORE: WaDeviceListStore;

package/dist/types/store/providers/memory/identity.store.d.ts

@@ -0,0 +1,18 @@
+import type { SignalAddress } from '../../../signal/types';
+import type { WaIdentityStore as WaIdentityStoreContract } from '../../contracts/identity.store';
+export interface WaIdentityMemoryStoreOptions {
+    readonly maxRemoteIdentities?: number;
+}
+export declare class WaIdentityMemoryStore implements WaIdentityStoreContract {
+    private readonly remoteIdentities;
+    private readonly maxRemoteIdentities;
+    constructor(options?: WaIdentityMemoryStoreOptions);
+    getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
+    getRemoteIdentities(addresses: readonly SignalAddress[]): Promise<readonly (Uint8Array | null)[]>;
+    setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
+    setRemoteIdentities(entries: readonly {
+        readonly address: SignalAddress;
+        readonly identityKey: Uint8Array;
+    }[]): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/memory/message-secret.store.d.ts

@@ -0,0 +1,21 @@
+import type { WaMessageSecretEntry, WaMessageSecretStore } from '../../contracts/message-secret.store';
+export interface WaMessageSecretMemoryStoreOptions {
+    readonly maxSecrets?: number;
+}
+export declare class WaMessageSecretMemoryStore implements WaMessageSecretStore {
+    private readonly secrets;
+    private readonly ttlMs;
+    private readonly maxSecrets;
+    private readonly cleanupTimer;
+    constructor(ttlMs?: number, options?: WaMessageSecretMemoryStoreOptions);
+    get(messageId: string, nowMs?: number): Promise<WaMessageSecretEntry | null>;
+    getBatch(messageIds: readonly string[], nowMs?: number): Promise<readonly (WaMessageSecretEntry | null)[]>;
+    set(messageId: string, entry: WaMessageSecretEntry): Promise<void>;
+    setBatch(entries: readonly {
+        readonly messageId: string;
+        readonly entry: WaMessageSecretEntry;
+    }[]): Promise<void>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/types/store/providers/memory/pre-key.store.d.ts

@@ -0,0 +1,23 @@
+import type { PreKeyRecord } from '../../../signal/types';
+import type { WaPreKeyStore as WaPreKeyStoreContract } from '../../contracts/pre-key.store';
+export interface WaPreKeyMemoryStoreOptions {
+    readonly maxPreKeys?: number;
+}
+export declare class WaPreKeyMemoryStore implements WaPreKeyStoreContract {
+    private readonly preKeys;
+    private readonly uploadedPreKeys;
+    private serverHasPreKeys;
+    private nextPreKeyId;
+    private readonly maxPreKeys;
+    constructor(options?: WaPreKeyMemoryStoreOptions);
+    putPreKey(record: PreKeyRecord): Promise<void>;
+    getOrGenPreKeys(count: number, generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<readonly PreKeyRecord[]>;
+    getPreKeyById(keyId: number): Promise<PreKeyRecord | null>;
+    getPreKeysById(keyIds: readonly number[]): Promise<readonly (PreKeyRecord | null)[]>;
+    consumePreKeyById(keyId: number): Promise<PreKeyRecord | null>;
+    getOrGenSinglePreKey(generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<PreKeyRecord>;
+    markKeyAsUploaded(keyId: number): Promise<void>;
+    setServerHasPreKeys(value: boolean): Promise<void>;
+    getServerHasPreKeys(): Promise<boolean>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/memory/retry.store.d.ts

@@ -1,12 +1,18 @@
 import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../../retry/types';
 import type { WaRetryStore } from '../../contracts/retry.store';
+export interface WaRetryMemoryStoreOptions {
+    readonly maxOutboundMessages?: number;
+    readonly maxInboundCounters?: number;
+}
 export declare class WaRetryMemoryStore implements WaRetryStore {
     private readonly outboundMessages;
     private readonly eligibleSets;
     private readonly inboundCounters;
     private readonly ttlMs;
+    private readonly maxOutboundMessages;
+    private readonly maxInboundCounters;
     private readonly cleanupTimer;
-    constructor(ttlMs?: number);
+    constructor(ttlMs?: number, options?: WaRetryMemoryStoreOptions);
     getTtlMs(): number;
     supportsRawReplayPayload(): boolean;
     getOutboundRequesterStatus(messageId: string, requesterDeviceJid: string): Promise<{

package/dist/types/store/providers/memory/session.store.d.ts

@@ -0,0 +1,21 @@
+import type { SignalAddress, SignalSessionRecord } from '../../../signal/types';
+import type { WaSessionStore as WaSessionStoreContract } from '../../contracts/session.store';
+export interface WaSessionMemoryStoreOptions {
+    readonly maxSessions?: number;
+}
+export declare class WaSessionMemoryStore implements WaSessionStoreContract {
+    private readonly signalSessions;
+    private readonly maxSessions;
+    constructor(options?: WaSessionMemoryStoreOptions);
+    hasSession(address: SignalAddress): Promise<boolean>;
+    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
+    getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
+    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
+    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
+    setSessionsBatch(entries: readonly {
+        readonly address: SignalAddress;
+        readonly session: SignalSessionRecord;
+    }[]): Promise<void>;
+    deleteSession(address: SignalAddress): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/memory/signal.store.d.ts

@@ -1,24 +1,10 @@
-import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../../signal/types';
-import type { WaSignalMetaSnapshot, WaSignalStore as WaSignalStoreContract } from '../../contracts/signal.store';
-export interface WaSignalMemoryStoreOptions {
-    readonly maxPreKeys?: number;
-    readonly maxSessions?: number;
-    readonly maxRemoteIdentities?: number;
-}
+import type { RegistrationInfo, SignedPreKeyRecord } from '../../../signal/types';
+import type { WaSignalStore as WaSignalStoreContract } from '../../contracts/signal.store';
 export declare class WaSignalMemoryStore implements WaSignalStoreContract {
     private registrationInfo;
     private signedPreKey;
     private signedPreKeyRotationTs;
-    private readonly preKeys;
-    private readonly uploadedPreKeys;
-    private serverHasPreKeys;
-    private readonly signalSessions;
-    private readonly remoteIdentities;
-    private nextPreKeyId;
-    private readonly maxPreKeys;
-    private readonly maxSessions;
-    private readonly maxRemoteIdentities;
-    constructor(options?: WaSignalMemoryStoreOptions);
+    constructor();
     getRegistrationInfo(): Promise<RegistrationInfo | null>;
     setRegistrationInfo(info: RegistrationInfo): Promise<void>;
     getSignedPreKey(): Promise<SignedPreKeyRecord | null>;
@@ -26,33 +12,5 @@ export declare class WaSignalMemoryStore implements WaSignalStoreContract {
     getSignedPreKeyById(keyId: number): Promise<SignedPreKeyRecord | null>;
     setSignedPreKeyRotationTs(value: number | null): Promise<void>;
     getSignedPreKeyRotationTs(): Promise<number | null>;
-    putPreKey(record: PreKeyRecord): Promise<void>;
-    getOrGenPreKeys(count: number, generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<readonly PreKeyRecord[]>;
-    getPreKeyById(keyId: number): Promise<PreKeyRecord | null>;
-    getPreKeysById(keyIds: readonly number[]): Promise<readonly (PreKeyRecord | null)[]>;
-    consumePreKeyById(keyId: number): Promise<PreKeyRecord | null>;
-    getOrGenSinglePreKey(generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<PreKeyRecord>;
-    markKeyAsUploaded(keyId: number): Promise<void>;
-    setServerHasPreKeys(value: boolean): Promise<void>;
-    getServerHasPreKeys(): Promise<boolean>;
-    getSignalMeta(): Promise<WaSignalMetaSnapshot>;
-    hasSession(address: SignalAddress): Promise<boolean>;
-    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
-    getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
-    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
-    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
-    setSessionsBatch(entries: readonly {
-        readonly address: SignalAddress;
-        readonly session: SignalSessionRecord;
-    }[]): Promise<void>;
-    deleteSession(address: SignalAddress): Promise<void>;
-    getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
-    getRemoteIdentities(addresses: readonly SignalAddress[]): Promise<readonly (Uint8Array | null)[]>;
-    setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
-    setRemoteIdentities(entries: readonly {
-        readonly address: SignalAddress;
-        readonly identityKey: Uint8Array;
-    }[]): Promise<void>;
     clear(): Promise<void>;
-    private addUploadedPreKey;
 }

package/dist/types/store/providers/memory/thread.store.d.ts

@@ -1,4 +1,4 @@
-import type { WaStoredThreadRecord, WaThreadStore as Contract } from '../../contracts/thread.store';
+import type { WaThreadStore as Contract, WaStoredThreadRecord } from '../../contracts/thread.store';
 export interface WaThreadMemoryStoreOptions {
     readonly maxThreads?: number;
 }

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

@@ -2,11 +2,15 @@ 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 WithDestroyLifecycle<T> = T & {
@@ -15,12 +19,16 @@ export type WithDestroyLifecycle<T> = T & {
 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;
@@ -36,6 +44,9 @@ 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;
@@ -47,6 +58,7 @@ export interface WaStoreBackend {
         readonly retry: (sessionId: string) => WaRetryStore;
         readonly participants: (sessionId: string) => WaParticipantsStore;
         readonly deviceList: (sessionId: string) => WaDeviceListStore;
+        readonly messageSecret: (sessionId: string) => WaMessageSecretStore;
     };
 }
 export type WaStoreDomain = keyof WaStoreBackend['stores'];
@@ -56,6 +68,9 @@ export interface WaCreateStoreOptions<B extends string = string> {
     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';
@@ -64,9 +79,10 @@ export interface WaCreateStoreOptions<B extends string = string> {
         readonly privacyToken?: B | 'memory';
     };
     readonly cacheProviders?: {
-        readonly retry?: B | 'memory';
+        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;
@@ -74,6 +90,7 @@ export interface WaCreateStoreOptions<B extends string = string> {
             readonly retryMs?: number;
             readonly participantsMs?: number;
             readonly deviceListMs?: number;
+            readonly messageSecretMs?: number;
         };
     };
 }
@@ -88,6 +105,9 @@ 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;
     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;

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,12 +5,14 @@ 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 readonly mobileIqIdFormat;
     private idGenerator;
     private idGeneratorReady;
     private readonly pendingQueries;
@@ -19,8 +21,10 @@ export declare class WaNodeOrchestrator {
     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 getIdGenerator;
 }

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/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/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/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/helpers.d.ts

@@ -2,6 +2,7 @@ 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;
@@ -16,6 +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>;

package/dist/types/transport/node/mex/persist-ids.d.ts

@@ -0,0 +1,14 @@
+export interface WaMexPersistId {
+    readonly docId: string;
+    readonly clientDocId: string;
+}
+export declare const WA_MEX_PERSIST_IDS: Readonly<{
+    WWWGetCertificates: Readonly<{
+        docId: "25094190163544446";
+        clientDocId: "16428758503015954638431529919";
+    }>;
+    WWWCreateUser: Readonly<{
+        docId: "8548056818544135";
+        clientDocId: "25777518041400352865446016972";
+    }>;
+}>;

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

@@ -0,0 +1,29 @@
+import { type Proto } from '../..';
+export interface WaMobileTransportDeviceInfo {
+    readonly manufacturer: string;
+    readonly device: string;
+    readonly osVersion: string;
+    readonly osBuildNumber: string;
+    readonly appVersion: string;
+    readonly mcc?: string;
+    readonly mnc?: string;
+    readonly localeLanguageIso6391?: string;
+    readonly localeCountryIso31661Alpha2?: string;
+    readonly phoneId?: string;
+    readonly deviceBoard?: string;
+    readonly deviceModelType?: string;
+}
+export interface WaMobileLoginPayloadConfig {
+    readonly username: number;
+    readonly device?: number;
+    readonly passive?: boolean;
+    readonly pull?: boolean;
+    readonly deviceInfo: WaMobileTransportDeviceInfo;
+    readonly lidDbMigrated?: boolean;
+    readonly connectReason?: Proto.ClientPayload.ConnectReason;
+    readonly connectType?: Proto.ClientPayload.ConnectType;
+    readonly pushName?: string;
+    readonly yearClass?: number;
+    readonly memClass?: number;
+}
+export declare function buildMobileLoginPayload(config: WaMobileLoginPayloadConfig): Uint8Array;