zapo-js 0.1.0 → 0.1.2

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

@@ -19,9 +19,15 @@ export interface WaSignalStore {
     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;

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

@@ -10,6 +10,7 @@ export interface WaStoredThreadRecord {
 }
 export interface WaThreadStore {
     upsert(record: WaStoredThreadRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredThreadRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredThreadRecord | null>;
     list(limit?: number): Promise<readonly WaStoredThreadRecord[]>;
     deleteByJid(jid: string): Promise<number>;

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

@@ -1,4 +1,4 @@
-export type { WaCreateStoreCustomCacheProviders, WaCreateStoreCustomProviders, WaCreateStoreOptions, WaSqliteDriver, WaSqliteStorageOptions, WaStoreSqliteBatchSizeSelection, WaStoreMemoryLimitSelection, WaStoreCacheProviderSelection, WaStoreCacheTtlSelection, WaStore, WaStoreDomainValueOrFactory, WaStoreProviderSelection, WaStoreSession } from './types';
+export type { WaCreateStoreCustomCacheProviders, WaCreateStoreCustomProviders, WaCreateStoreOptions, WaSqliteDriver, WaSqliteTableName, WaSqliteTableNameOverrides, WaSqliteStorageOptions, WaStoreSqliteBatchSizeSelection, WaStoreMemoryLimitSelection, WaStoreCacheProviderSelection, WaStoreCacheTtlSelection, WaStore, WaStoreDomainValueOrFactory, WaStoreProviderSelection, WaStoreSession } from './types';
 export { WaAuthSqliteStore } from './providers/sqlite/auth.store';
 export { WaAppStateSqliteStore } from './providers/sqlite/appstate.store';
 export { createStore } from './createStore';

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

@@ -14,8 +14,10 @@ export declare class WaAppStateMemoryStore implements WaAppStateStore {
     upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
     getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
     getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
+    getSyncKeyDataBatch(keyIds: readonly Uint8Array[]): Promise<readonly (Uint8Array | null)[]>;
     getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;
     getCollectionState(collection: AppStateCollectionName): Promise<WaAppStateCollectionStoreState>;
+    getCollectionStates(collections: readonly AppStateCollectionName[]): Promise<readonly WaAppStateCollectionStoreState[]>;
     setCollectionStates(updates: readonly WaAppStateCollectionStateUpdate[]): Promise<void>;
     clear(): Promise<void>;
 }

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

@@ -7,6 +7,7 @@ export declare class WaContactMemoryStore implements Contract {
     private readonly maxContacts;
     constructor(options?: WaContactMemoryStoreOptions);
     upsert(record: WaStoredContactRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredContactRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredContactRecord | null>;
     deleteByJid(jid: string): Promise<number>;
     clear(): Promise<void>;

package/dist/types/store/providers/memory/device-list.store.d.ts

@@ -8,10 +8,7 @@ export declare class WaDeviceListMemoryStore implements WaDeviceListStore {
     private readonly maxUsers;
     private readonly cleanupTimer;
     constructor(ttlMs?: number, options?: WaDeviceListMemoryStoreOptions);
-    getTtlMs(): number;
-    upsertUserDevices(snapshot: WaDeviceListSnapshot): Promise<void>;
     upsertUserDevicesBatch(snapshots: readonly WaDeviceListSnapshot[]): Promise<void>;
-    getUserDevices(userJid: string, nowMs?: number): Promise<WaDeviceListSnapshot | null>;
     getUserDevicesBatch(userJids: readonly string[], nowMs?: number): Promise<readonly (WaDeviceListSnapshot | null)[]>;
     deleteUserDevices(userJid: string): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;

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

@@ -7,6 +7,7 @@ export declare class WaMessageMemoryStore implements Contract {
     private readonly maxMessages;
     constructor(options?: WaMessageMemoryStoreOptions);
     upsert(record: WaStoredMessageRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredMessageRecord[]): Promise<void>;
     getById(id: string): Promise<WaStoredMessageRecord | null>;
     listByThread(threadJid: string, limit?: number, beforeTimestampMs?: number): Promise<readonly WaStoredMessageRecord[]>;
     deleteById(id: string): Promise<number>;

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

@@ -8,7 +8,6 @@ export declare class WaParticipantsMemoryStore implements WaParticipantsStore {
     private readonly maxGroups;
     private readonly cleanupTimer;
     constructor(ttlMs?: number, options?: WaParticipantsMemoryStoreOptions);
-    getTtlMs(): number;
     upsertGroupParticipants(snapshot: WaParticipantsSnapshot): Promise<void>;
     getGroupParticipants(groupJid: string, nowMs?: number): Promise<WaParticipantsSnapshot | null>;
     deleteGroupParticipants(groupJid: string): Promise<number>;

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

@@ -18,7 +18,6 @@ export declare class SenderKeyMemoryStore implements WaSenderKeyStoreContract {
         readonly skDistribList: readonly SenderKeyDistributionRecord[];
     }>;
     getDeviceSenderKey(groupId: string, sender: SignalAddress): Promise<SenderKeyRecord | null>;
-    getDeviceSenderKeyDistribution(groupId: string, sender: SignalAddress): Promise<SenderKeyDistributionRecord | null>;
     getDeviceSenderKeyDistributions(groupId: string, senders: readonly SignalAddress[]): Promise<readonly (SenderKeyDistributionRecord | null)[]>;
     deleteDeviceSenderKey(target: SignalAddress, groupId?: string): Promise<number>;
     markForgetSenderKey(groupId: string, participants: readonly SignalAddress[]): Promise<number>;

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

@@ -38,9 +38,15 @@ export declare class WaSignalMemoryStore implements WaSignalStoreContract {
     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;

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

@@ -7,6 +7,7 @@ export declare class WaThreadMemoryStore implements Contract {
     private readonly maxThreads;
     constructor(options?: WaThreadMemoryStoreOptions);
     upsert(record: WaStoredThreadRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredThreadRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredThreadRecord | null>;
     list(limit?: number): Promise<readonly WaStoredThreadRecord[]>;
     deleteByJid(jid: string): Promise<number>;

package/dist/types/store/providers/sqlite/appstate.store.d.ts

@@ -8,8 +8,10 @@ export declare class WaAppStateSqliteStore extends BaseSqliteStore implements Wa
     upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
     getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
     getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
+    getSyncKeyDataBatch(keyIds: readonly Uint8Array[]): Promise<readonly (Uint8Array | null)[]>;
     getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;
     getCollectionState(collection: AppStateCollectionName): Promise<WaAppStateCollectionStoreState>;
+    getCollectionStates(collections: readonly AppStateCollectionName[]): Promise<readonly WaAppStateCollectionStoreState[]>;
     setCollectionStates(updates: readonly WaAppStateCollectionStateUpdate[]): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/types/store/providers/sqlite/contact.store.d.ts

@@ -4,7 +4,9 @@ import type { WaSqliteStorageOptions } from '../../types';
 export declare class WaContactSqliteStore extends BaseSqliteStore implements Contract {
     constructor(options: WaSqliteStorageOptions);
     upsert(record: WaStoredContactRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredContactRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredContactRecord | null>;
     deleteByJid(jid: string): Promise<number>;
     clear(): Promise<void>;
+    private upsertContactRow;
 }

package/dist/types/store/providers/sqlite/device-list.store.d.ts

@@ -5,10 +5,7 @@ export declare class WaDeviceListSqliteStore extends BaseSqliteStore implements
     private readonly ttlMs;
     private readonly batchSize;
     constructor(options: WaSqliteStorageOptions, ttlMs?: number, batchSize?: number);
-    getTtlMs(): number;
-    upsertUserDevices(snapshot: WaDeviceListSnapshot): Promise<void>;
     upsertUserDevicesBatch(snapshots: readonly WaDeviceListSnapshot[]): Promise<void>;
-    getUserDevices(userJid: string, nowMs?: number): Promise<WaDeviceListSnapshot | null>;
     getUserDevicesBatch(userJids: readonly string[], nowMs?: number): Promise<readonly (WaDeviceListSnapshot | null)[]>;
     deleteUserDevices(userJid: string): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;

package/dist/types/store/providers/sqlite/message.store.d.ts

@@ -4,8 +4,10 @@ import type { WaSqliteStorageOptions } from '../../types';
 export declare class WaMessageSqliteStore extends BaseSqliteStore implements Contract {
     constructor(options: WaSqliteStorageOptions);
     upsert(record: WaStoredMessageRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredMessageRecord[]): Promise<void>;
     getById(id: string): Promise<WaStoredMessageRecord | null>;
     listByThread(threadJid: string, limit?: number, beforeTimestampMs?: number): Promise<readonly WaStoredMessageRecord[]>;
     deleteById(id: string): Promise<number>;
     clear(): Promise<void>;
+    private upsertMessageRow;
 }

package/dist/types/store/providers/sqlite/participants.store.d.ts

@@ -4,7 +4,6 @@ import type { WaSqliteStorageOptions } from '../../types';
 export declare class WaParticipantsSqliteStore extends BaseSqliteStore implements WaParticipantsStore {
     private readonly ttlMs;
     constructor(options: WaSqliteStorageOptions, ttlMs?: number);
-    getTtlMs(): number;
     upsertGroupParticipants(snapshot: WaParticipantsSnapshot): Promise<void>;
     getGroupParticipants(groupJid: string, nowMs?: number): Promise<WaParticipantsSnapshot | null>;
     deleteGroupParticipants(groupJid: string): Promise<number>;

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

@@ -12,5 +12,4 @@ export declare class WaRetrySqliteStore extends BaseSqliteStore implements WaRet
     incrementInboundCounter(messageId: string, requesterJid: string, updatedAtMs: number, expiresAtMs: number): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;
     clear(): Promise<void>;
-    private countRows;
 }

package/dist/types/store/providers/sqlite/sender-key.store.d.ts

@@ -13,7 +13,6 @@ export declare class SenderKeySqliteStore extends BaseSqliteStore implements WaS
         readonly skDistribList: readonly SenderKeyDistributionRecord[];
     }>;
     getDeviceSenderKey(groupId: string, sender: SignalAddress): Promise<SenderKeyRecord | null>;
-    getDeviceSenderKeyDistribution(groupId: string, sender: SignalAddress): Promise<SenderKeyDistributionRecord | null>;
     getDeviceSenderKeyDistributions(groupId: string, senders: readonly SignalAddress[]): Promise<readonly (SenderKeyDistributionRecord | null)[]>;
     deleteDeviceSenderKey(target: SignalAddress, groupId?: string): Promise<number>;
     markForgetSenderKey(groupId: string, participants: readonly SignalAddress[]): Promise<number>;

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

@@ -29,9 +29,15 @@ export declare class WaSignalSqliteStore extends BaseSqliteStore implements WaSi
     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;
@@ -39,6 +45,7 @@ export declare class WaSignalSqliteStore extends BaseSqliteStore implements WaSi
     }[]): Promise<void>;
     clear(): Promise<void>;
     private upsertPreKey;
+    private upsertSession;
     private ensureMetaRow;
     private getMeta;
     private upsertRemoteIdentity;

package/dist/types/store/providers/sqlite/table-names.d.ts

@@ -0,0 +1,5 @@
+import type { WaSqliteTableName, WaSqliteTableNameOverrides } from '../../types';
+export declare const WA_SQLITE_DEFAULT_TABLE_NAMES: Readonly<Record<WaSqliteTableName, string>>;
+export declare function resolveSqliteTableNames(overrides?: WaSqliteTableNameOverrides): Readonly<Record<WaSqliteTableName, string>>;
+export declare function serializeSqliteTableNames(tableNames: Readonly<Record<WaSqliteTableName, string>>): string;
+export declare function createSqliteTableNameSqlResolver(tableNames: Readonly<Record<WaSqliteTableName, string>>): (sql: string) => string;

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

@@ -4,8 +4,10 @@ import type { WaSqliteStorageOptions } from '../../types';
 export declare class WaThreadSqliteStore extends BaseSqliteStore implements Contract {
     constructor(options: WaSqliteStorageOptions);
     upsert(record: WaStoredThreadRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredThreadRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredThreadRecord | null>;
     list(limit?: number): Promise<readonly WaStoredThreadRecord[]>;
     deleteByJid(jid: string): Promise<number>;
     clear(): Promise<void>;
+    private upsertThreadRow;
 }

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

@@ -9,11 +9,14 @@ import type { WaSenderKeyStore } from './contracts/sender-key.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 interface WaStoreSession {
     readonly auth: WaAuthStore;

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

@@ -10,6 +10,7 @@ export declare class WaWebSocket {
     private handlers;
     private socket;
     private closeWaiter;
+    private nodeWsCtorPromise;
     constructor(config: WaSocketConfig, logger?: Logger);
     setHandlers(handlers: WaSocketHandlers): void;
     isOpen(): boolean;
@@ -20,6 +21,7 @@ export declare class WaWebSocket {
     send(data: string | ArrayBuffer | Uint8Array): Promise<void>;
     private openSingle;
     private openConcurrently;
+    private releasePendingSocketsAfterSetupFailure;
     private bindRuntimeHandlers;
     private handleMessage;
     private normalizePayload;
@@ -33,4 +35,5 @@ export declare class WaWebSocket {
     private handleRuntimeClose;
     private closeSocketSafe;
     private createRawSocket;
+    private resolveNodeWsConstructor;
 }

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

@@ -1,4 +1,5 @@
-export type { BinaryNode, RawWebSocket, RawWebSocketConstructor, SocketCloseInfo, SocketOpenInfo, WaCommsConfig, WaCommsState, WaNoiseConfig, WaSocketConfig, WaSocketHandlers } from './types';
+export type { BinaryNode, RawWebSocket, RawWebSocketConstructor, WaRawWebSocketInit, SocketCloseInfo, SocketOpenInfo, WaCommsConfig, WaCommsState, WaNoiseConfig, WaProxyAgent, WaProxyDispatcher, WaProxyTransport, WaSocketConfig, WaSocketHandlers } from './types';
+export { isProxyAgent, isProxyDispatcher, isProxyTransport, toProxyAgent, toProxyDispatcher } from './proxy';
 export { WaComms } from './WaComms';
 export { WaWebSocket } from './WaWebSocket';
 export { WaKeepAlive } from './keepalive/WaKeepAlive';

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

@@ -32,7 +32,6 @@ export declare class WaKeepAlive {
     private schedule;
     private run;
     private normalizeJitterRatio;
-    private normalizeMinJitterMs;
     private computeNextDelayMs;
     private clearTimer;
 }

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

@@ -2,21 +2,12 @@ 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/group.d.ts

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

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

@@ -1,7 +1,8 @@
-export { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../../node/builders/accountSync';
+export { buildAccountBlocklistSyncIq, buildAccountDevicesSyncIq, buildAccountPictureSyncIq, buildAccountPrivacySyncIq, buildClearDirtyBitsIq, buildGroupsDirtySyncIq, buildNewsletterMetadataSyncIq } from '../../node/builders/account-sync';
 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';
+export { buildUsyncIq, buildUsyncUserNode, type BuildUsyncIqInput, type BuildUsyncUserNodeInput, type WaUsyncContext, type WaUsyncMode } from '../../node/builders/usync';

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

@@ -4,33 +4,22 @@ interface EncryptedParticipant {
     readonly encType: 'msg' | 'pkmsg';
     readonly ciphertext: Uint8Array;
 }
-interface BuildDirectMessageFanoutNodeInput {
+type DirectMessageFanoutInput = {
     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 reportingNode?: BinaryNode;
+};
+type GroupMessageFanoutInput = DirectMessageFanoutInput & {
     readonly phash?: string;
     readonly addressingMode?: 'pn' | 'lid';
-    readonly participants: readonly EncryptedParticipant[];
-    readonly deviceIdentity?: Uint8Array;
-}
-interface BuildGroupRetryMessageNodeInput {
+};
+type GroupSenderKeyMessageInput = GroupMessageFanoutInput & {
+    readonly groupCiphertext: Uint8Array;
+};
+type GroupRetryMessageInput = {
     readonly to: string;
     readonly type: string;
     readonly id: string;
@@ -39,14 +28,14 @@ interface BuildGroupRetryMessageNodeInput {
     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 buildDirectMessageFanoutNode(input: DirectMessageFanoutInput): 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: BuildGroupRetryMessageNodeInput): BinaryNode;
+export declare function buildGroupRetryMessageNode(input: GroupRetryMessageInput): BinaryNode;
 export {};

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

@@ -1,6 +1,6 @@
 import type { WaRetryKeyBundle } from '../../../retry/types';
 import type { BinaryNode } from '../../types';
-interface BuildRetryReceiptNodeInput {
+export declare function buildRetryReceiptNode(input: {
     readonly stanzaId: string;
     readonly to: string;
     readonly participant?: string;
@@ -13,6 +13,4 @@ interface BuildRetryReceiptNodeInput {
     readonly error?: number;
     readonly categoryPeer?: boolean;
     readonly keys?: WaRetryKeyBundle;
-}
-export declare function buildRetryReceiptNode(input: BuildRetryReceiptNodeInput): BinaryNode;
-export {};
+}): BinaryNode;

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

@@ -0,0 +1,21 @@
+import { WA_USYNC_CONTEXTS, WA_USYNC_MODES } from '../../../protocol/constants';
+import type { BinaryNode } from '../../types';
+export type WaUsyncMode = (typeof WA_USYNC_MODES)[keyof typeof WA_USYNC_MODES];
+export type WaUsyncContext = (typeof WA_USYNC_CONTEXTS)[keyof typeof WA_USYNC_CONTEXTS];
+export interface BuildUsyncUserNodeInput {
+    readonly jid: string;
+    readonly attrs?: Readonly<Record<string, string>>;
+    readonly content?: BinaryNode['content'];
+}
+export interface BuildUsyncIqInput {
+    readonly sid: string;
+    readonly queryProtocolNodes: readonly BinaryNode[];
+    readonly users: readonly BuildUsyncUserNodeInput[];
+    readonly mode?: WaUsyncMode;
+    readonly context?: WaUsyncContext;
+    readonly index?: string;
+    readonly last?: string;
+    readonly hostDomain?: string;
+}
+export declare function buildUsyncUserNode(input: BuildUsyncUserNodeInput): BinaryNode;
+export declare function buildUsyncIq(input: BuildUsyncIqInput): BinaryNode;

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

@@ -3,6 +3,14 @@ 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 getNodeChildrenByTagFromChildren(node: BinaryNode, tag: string): readonly BinaryNode[];
+export declare function getNodeChildrenTags(node: BinaryNode): readonly string[];
+export declare function getNodeChildrenNonEmptyAttrValuesByTag(node: BinaryNode, tag: string, attr: string): readonly string[];
+export declare function getNodeChildrenNonEmptyUtf8ByTag(node: BinaryNode, tag: string, field: string): readonly string[];
+export declare function findNodeChildrenByTags<const TTags extends readonly string[]>(node: BinaryNode, tags: TTags): {
+    readonly [Index in keyof TTags]: BinaryNode | undefined;
+};
 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;
+export declare function formatNodeIdPrefixFromSeed(seed: Uint8Array): string;

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

@@ -0,0 +1,2 @@
+export type WaUsyncSidGenerator = () => Promise<string>;
+export declare function createUsyncSidGenerator(): WaUsyncSidGenerator;

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

@@ -3,7 +3,10 @@ export declare class WaFrameCodec {
     private readonly maxFrameLength;
     private introSent;
     private buffered;
+    private bufferedLength;
     constructor(introFrame?: Uint8Array, maxFrameLength?: number);
+    private assertFrameLength;
+    private appendBuffered;
     encodeFrame(frame: Uint8Array): Uint8Array;
     pushWireChunk(chunk: Uint8Array): readonly Uint8Array[];
 }

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

@@ -7,6 +7,7 @@ export declare class WaNoiseSession {
     private readonly readQueue;
     private frameCodec;
     private handshakeInbox;
+    private handshakeInboxHead;
     private handshakeWaiter;
     private handshakeRejecter;
     private pendingDecryptedFrames;

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

@@ -0,0 +1,6 @@
+import type { WaProxyAgent, WaProxyDispatcher, WaProxyTransport } from './types';
+export declare function isProxyDispatcher(value: unknown): value is WaProxyDispatcher;
+export declare function isProxyAgent(value: unknown): value is WaProxyAgent;
+export declare function isProxyTransport(value: unknown): value is WaProxyTransport;
+export declare function toProxyDispatcher(proxy: WaProxyTransport | undefined): WaProxyDispatcher | undefined;
+export declare function toProxyAgent(proxy: WaProxyTransport | undefined): WaProxyAgent | undefined;

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

@@ -18,6 +18,5 @@ export type WaStreamControlNodeResult = {
     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

@@ -1,5 +1,12 @@
+import type { Agent as HttpAgent } from 'node:http';
+import type { Agent as HttpsAgent } from 'node:https';
 import type { SignalKeyPair } from '../crypto/curves/types';
 import type { WaLoginPayloadConfig, WaRegistrationPayloadConfig } from './noise/types';
+export interface WaProxyDispatcher {
+    dispatch(...args: readonly unknown[]): unknown;
+}
+export type WaProxyAgent = HttpAgent | HttpsAgent;
+export type WaProxyTransport = WaProxyDispatcher | WaProxyAgent;
 export interface BinaryNode {
     readonly tag: string;
     readonly attrs: Readonly<Record<string, string>>;
@@ -18,6 +25,8 @@ export interface WaSocketConfig {
     readonly urls?: readonly string[];
     readonly protocols?: readonly string[];
     readonly headers?: Readonly<Record<string, string>>;
+    readonly dispatcher?: WaProxyDispatcher;
+    readonly agent?: WaProxyAgent;
     readonly timeoutIntervalMs?: number;
 }
 export interface WaSocketHandlers {
@@ -66,6 +75,14 @@ export interface RawWebSocket {
     close(code?: number, reason?: string): void;
     send(data: string | ArrayBuffer | Uint8Array): void;
 }
-export type RawWebSocketConstructor = new (url: string, protocols?: string | readonly string[], options?: {
+export interface WaRawWebSocketInit {
+    readonly protocols?: string | readonly string[];
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly dispatcher?: WaProxyDispatcher;
+    readonly agent?: WaProxyAgent;
+}
+export type RawWebSocketConstructor = new (url: string, protocols?: string | readonly string[] | WaRawWebSocketInit, options?: {
     headers?: Readonly<Record<string, string>>;
+    dispatcher?: WaProxyDispatcher;
+    agent?: WaProxyAgent;
 }) => RawWebSocket;

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

@@ -1,6 +1,7 @@
 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 ZERO_BYTES: Readonly<Uint8Array>;
 export declare const EMPTY_BYTES: Readonly<Uint8Array<ArrayBuffer>>;
 /**
  * Encodes a Uint8Array to a hex string
@@ -12,6 +13,10 @@ export declare function bytesToHex(value: Uint8Array): string;
 export declare function hexToBytes(value: string): Uint8Array;
 export declare function bytesToBase64(value: Uint8Array): string;
 export declare function base64ToBytes(value: string): Uint8Array;
+export declare function base64ToBytesChecked(value: string, field: string, requireNonEmpty?: boolean): Uint8Array;
+export declare function decodeBase64Url(value: string | undefined, field: string): Uint8Array;
+export declare function assertByteLength(value: Uint8Array, expectedLength: number, errorMessage: string, throwOnMismatch?: boolean): boolean;
+export declare function decodeProtoBytes(value: Uint8Array | string | null | undefined, field: string): Uint8Array;
 /**
  * Encodes a Uint8Array to a base64url string (URL-safe, no padding)
  */

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

@@ -5,3 +5,6 @@ export declare function toSafeNumber(value: number | {
 export declare function longToNumber(value: number | {
     toNumber(): number;
 } | null | undefined): number;
+export declare function normalizeNonNegativeInteger(value: number | undefined, fallback: number): number;
+export declare function parseStrictUnsignedInt(value: string): number | undefined;
+export declare function parseOptionalInt(value: string | undefined): number | undefined;