zapo-js 0.1.2 → 0.2.0

package/dist/types/client/WaClient.d.ts

@@ -2,9 +2,14 @@ import { EventEmitter } from 'node:events';
 import type { WaAppStateStoreData, WaAppStateSyncResult } from '../appstate/types';
 import type { WaAppStateSyncOptions } from '../appstate/types';
 import type { WaAppStateSyncClient } from '../appstate/WaAppStateSyncClient';
+import type { WaAppStateMutationCoordinator } from './coordinators/WaAppStateMutationCoordinator';
+import type { WaBusinessCoordinator } from './coordinators/WaBusinessCoordinator';
 import type { WaGroupCoordinator } from './coordinators/WaGroupCoordinator';
 import type { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator';
-import type { WaAppStateMessageKey, WaClearChatOptions, WaClientOptions, WaDeleteChatOptions, WaDeleteMessageForMeOptions, WaSendMessageOptions, WaClientEventMap, WaIncomingNodeHandlerRegistration } from './types';
+import type { WaPrivacyCoordinator } from './coordinators/WaPrivacyCoordinator';
+import type { WaProfileCoordinator } from './coordinators/WaProfileCoordinator';
+import type { WriteBehindDrainResult } from './persistence/WriteBehindPersistence';
+import type { WaClientOptions, WaSendMessageOptions, WaClientEventMap, WaIncomingNodeHandlerRegistration } from './types';
 import type { Logger } from '../infra/log/types';
 import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import type { WaMessagePublishResult, WaSendMessageContent, WaSendReceiptInput } from '../message/types';
@@ -18,6 +23,7 @@ export declare class WaClient extends EventEmitter {
     private readonly contactStore;
     private readonly messageStore;
     private readonly participantsStore;
+    private readonly privacyTokenStore;
     private readonly deviceListStore;
     private readonly retryStore;
     private readonly signalStore;
@@ -28,18 +34,26 @@ export declare class WaClient extends EventEmitter {
     private readonly nodeTransport;
     private readonly signalDeviceSync;
     readonly appStateSync: WaAppStateSyncClient;
-    private readonly appStateMutations;
+    readonly chatCoordinator: WaAppStateMutationCoordinator;
     private readonly incomingNode;
     readonly mediaTransfer: WaMediaTransferClient;
     readonly messageDispatch: WaMessageDispatchCoordinator;
     readonly messageClient: WaMessageClient;
     readonly groupCoordinator: WaGroupCoordinator;
+    readonly privacyCoordinator: WaPrivacyCoordinator;
+    readonly profileCoordinator: WaProfileCoordinator;
+    readonly businessCoordinator: WaBusinessCoordinator;
     private readonly passiveTasks;
     private readonly keepAlive;
     private readonly receiptQueue;
     private readonly keyShareCoordinator;
     private readonly connectionManager;
+    private readonly trustedContactToken;
+    private readonly writeBehind;
     private connectPromise;
+    private acceptingIncomingEvents;
+    private activeIncomingHandlers;
+    private readonly incomingHandlersDrainedWaiters;
     constructor(options: WaClientOptions, logger?: Logger);
     on<K extends keyof WaClientEventMap>(event: K, listener: WaClientEventMap[K]): this;
     on(event: string | symbol, listener: (...args: unknown[]) => void): this;
@@ -62,7 +76,6 @@ export declare class WaClient extends EventEmitter {
     registerIncomingHandler(registration: WaIncomingNodeHandlerRegistration): () => void;
     unregisterIncomingHandler(registration: WaIncomingNodeHandlerRegistration): boolean;
     private bindNodeTransportEvents;
-    private getMailboxPersistenceDeps;
     private handleIncomingMessageEvent;
     private handleIncomingAppStateSyncKeyShare;
     private handleIncomingAppStateSyncKeyRequest;
@@ -78,22 +91,24 @@ export declare class WaClient extends EventEmitter {
     getLidsByPhoneNumbers(phoneNumbers: readonly string[]): Promise<readonly SignalLidSyncResult[]>;
     sendMessage(to: string, content: WaSendMessageContent, options?: WaSendMessageOptions): Promise<WaMessagePublishResult>;
     syncSignalSession(jid: string, reasonIdentity?: boolean): Promise<void>;
+    get chat(): WaAppStateMutationCoordinator;
+    get group(): WaGroupCoordinator;
+    get privacy(): WaPrivacyCoordinator;
+    get profile(): WaProfileCoordinator;
+    get business(): WaBusinessCoordinator;
     sendReceipt(input: WaSendReceiptInput): Promise<void>;
-    setChatMute(chatJid: string, muted: boolean, muteEndTimestampMs?: number): Promise<void>;
-    setChatRead(chatJid: string, read: boolean): Promise<void>;
-    setChatPin(chatJid: string, pinned: boolean): Promise<void>;
-    setChatArchive(chatJid: string, archived: boolean): Promise<void>;
-    clearChat(chatJid: string, options?: WaClearChatOptions): Promise<void>;
-    deleteChat(chatJid: string, options?: WaDeleteChatOptions): Promise<void>;
-    setChatLock(chatJid: string, locked: boolean): Promise<void>;
-    setMessageStar(message: WaAppStateMessageKey, starred: boolean): Promise<void>;
-    deleteMessageForMe(message: WaAppStateMessageKey, options?: WaDeleteMessageForMeOptions): Promise<void>;
     flushAppStateMutations(): Promise<void>;
+    flushWriteBehind(timeoutMs?: number): Promise<WriteBehindDrainResult>;
     exportAppState(): Promise<WaAppStateStoreData>;
     syncAppState(options?: WaAppStateSyncOptions): Promise<WaAppStateSyncResult>;
     private executeAppStateSync;
     private getBlockedAppStateCollections;
     private emitChatEventsFromAppStateSyncResult;
+    private handleNctSaltMutation;
     private clearStoredState;
+    private tryEnterIncomingHandler;
+    private leaveIncomingHandler;
+    private pauseIncomingEventsAndWaitDrain;
+    private notifyIncomingHandlersDrained;
     private handleError;
 }

package/dist/types/client/WaClientFactory.d.ts

@@ -5,13 +5,17 @@ import { WaConnectionManager } from './connection/WaConnectionManager';
 import { WaKeyShareCoordinator } from './connection/WaKeyShareCoordinator';
 import { WaReceiptQueue } from './connection/WaReceiptQueue';
 import { WaAppStateMutationCoordinator } from './coordinators/WaAppStateMutationCoordinator';
+import { type WaBusinessCoordinator } from './coordinators/WaBusinessCoordinator';
 import { type WaGroupCoordinator } from './coordinators/WaGroupCoordinator';
 import { WaIncomingNodeCoordinator } from './coordinators/WaIncomingNodeCoordinator';
 import { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator';
 import { WaPassiveTasksCoordinator } from './coordinators/WaPassiveTasksCoordinator';
+import { type WaPrivacyCoordinator } from './coordinators/WaPrivacyCoordinator';
+import { type WaProfileCoordinator } from './coordinators/WaProfileCoordinator';
 import { WaRetryCoordinator } from './coordinators/WaRetryCoordinator';
 import { type WaStreamControlHandler } from './coordinators/WaStreamControlCoordinator';
-import { buildMediaMessageContent } from './messages';
+import { WaTrustedContactTokenCoordinator } from './coordinators/WaTrustedContactTokenCoordinator';
+import { type WaMediaMessageOptions } from './messages';
 import type { WaClientEventMap, WaClientOptions, WaIncomingMessageEvent } from './types';
 import type { Logger } from '../infra/log/types';
 import { WaMediaTransferClient } from '../media/WaMediaTransferClient';
@@ -28,7 +32,6 @@ import { WaKeepAlive } from '../transport/keepalive/WaKeepAlive';
 import { WaNodeOrchestrator } from '../transport/node/WaNodeOrchestrator';
 import { WaNodeTransport } from '../transport/node/WaNodeTransport';
 import type { BinaryNode } from '../transport/types';
-type WaMediaMessageBuildOptions = Parameters<typeof buildMediaMessageContent>[0];
 interface WaClientBase {
     readonly options: Readonly<WaClientOptions>;
     readonly logger: Logger;
@@ -45,13 +48,14 @@ interface WaClientBuildRuntime {
     readonly handleError: (error: Error) => void;
     readonly handleIncomingFrame: (frame: Uint8Array) => Promise<void>;
     readonly clearStoredState: () => Promise<void>;
+    readonly resumeIncomingEvents: () => void;
 }
 interface WaClientDependencies {
     readonly nodeTransport: WaNodeTransport;
     readonly nodeOrchestrator: WaNodeOrchestrator;
     readonly keepAlive: WaKeepAlive;
     readonly mediaTransfer: WaMediaTransferClient;
-    readonly mediaMessageBuildOptions: WaMediaMessageBuildOptions;
+    readonly mediaMessageBuildOptions: WaMediaMessageOptions;
     readonly messageClient: WaMessageClient;
     readonly senderKeyManager: SenderKeyManager;
     readonly signalProtocol: SignalProtocol;
@@ -65,14 +69,18 @@ interface WaClientDependencies {
     readonly messageDispatch: WaMessageDispatchCoordinator;
     readonly retryCoordinator: WaRetryCoordinator;
     readonly appStateSync: WaAppStateSyncClient;
-    readonly appStateMutations: WaAppStateMutationCoordinator;
+    readonly chatCoordinator: WaAppStateMutationCoordinator;
     readonly streamControl: WaStreamControlHandler;
     readonly incomingNode: WaIncomingNodeCoordinator;
     readonly passiveTasks: WaPassiveTasksCoordinator;
     readonly groupCoordinator: WaGroupCoordinator;
+    readonly privacyCoordinator: WaPrivacyCoordinator;
+    readonly profileCoordinator: WaProfileCoordinator;
+    readonly businessCoordinator: WaBusinessCoordinator;
     readonly receiptQueue: WaReceiptQueue;
     readonly keyShareCoordinator: WaKeyShareCoordinator;
     readonly connectionManager: WaConnectionManager;
+    readonly trustedContactToken: WaTrustedContactTokenCoordinator;
 }
 export declare function resolveWaClientBase(options: WaClientOptions, logger: Logger): WaClientBase;
 export declare function buildWaClientDependencies(input: {

package/dist/types/client/connection/WaConnectionManager.d.ts

@@ -35,12 +35,14 @@ export declare class WaConnectionManager {
     private pendingComms;
     private lifecycleGeneration;
     private lifecycleQueue;
+    private lastConnectWasNewLogin;
     constructor(options: WaConnectionManagerOptions);
     connect(frameHandler: (frame: Uint8Array) => Promise<void>): Promise<void>;
     scheduleReconnectAfterPairing(): void;
     disconnect(): Promise<void>;
     clearStoredCredentials(): Promise<void>;
     isConnected(): boolean;
+    wasNewLogin(): boolean;
     getComms(): WaComms | null;
     getClockSkewMs(): number | null;
     getMediaConnCache(): WaMediaConn | null;

package/dist/types/client/coordinators/WaBusinessCoordinator.d.ts

@@ -0,0 +1,57 @@
+import type { WaEditBusinessProfileInput } from '../../transport/node/builders/business';
+import type { BinaryNode } from '../../transport/types';
+export interface WaBusinessCategory {
+    readonly id: string;
+    readonly name: string;
+}
+export interface WaBusinessHoursEntry {
+    readonly dayOfWeek: string;
+    readonly mode: string;
+    readonly openTime?: number;
+    readonly closeTime?: number;
+}
+export interface WaBusinessHours {
+    readonly timezone?: string;
+    readonly config: readonly WaBusinessHoursEntry[];
+}
+export interface WaBusinessWebsite {
+    readonly url: string;
+}
+export interface WaBusinessProfileResult {
+    readonly jid: string;
+    readonly tag?: string;
+    readonly description?: string;
+    readonly address?: string;
+    readonly email?: string;
+    readonly websites?: readonly WaBusinessWebsite[];
+    readonly categories?: readonly WaBusinessCategory[];
+    readonly businessHours?: WaBusinessHours;
+    readonly latitude?: number;
+    readonly longitude?: number;
+    readonly profileOptions?: Readonly<Record<string, string>>;
+}
+export interface WaVerifiedNamePrivacyMode {
+    readonly actualActors: number;
+    readonly hostStorage: number;
+    readonly privacyModeTs: number;
+}
+export interface WaVerifiedNameResult {
+    readonly name?: string;
+    readonly level?: string;
+    readonly serial?: string;
+    readonly isApi: boolean;
+    readonly isSmb: boolean;
+    readonly privacyMode?: WaVerifiedNamePrivacyMode;
+}
+export interface WaBusinessCoordinator {
+    readonly getBusinessProfile: (jids: readonly string[]) => Promise<readonly WaBusinessProfileResult[]>;
+    readonly editBusinessProfile: (input: WaEditBusinessProfileInput) => Promise<void>;
+    readonly getVerifiedName: (jid: string) => Promise<WaVerifiedNameResult | null>;
+    readonly updateCoverPhoto: (id: string, timestamp: string, token: string) => Promise<void>;
+    readonly deleteCoverPhoto: (id: string) => Promise<void>;
+}
+interface WaBusinessCoordinatorOptions {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+}
+export declare function createBusinessCoordinator(options: WaBusinessCoordinatorOptions): WaBusinessCoordinator;
+export {};

package/dist/types/client/coordinators/WaIncomingNodeCoordinator.d.ts

@@ -2,6 +2,7 @@ import type { WaSuccessPersistAttributes } from '../../auth/types';
 import type { WaDirtyBit } from '../dirty';
 import type { WaIncomingBaseEvent, WaIncomingCallEvent, WaIncomingChatstateEvent, WaIncomingFailureEvent, WaGroupEvent, WaIncomingNodeHandlerRegistration, WaIncomingNotificationEvent, WaIncomingPresenceEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent } from '../types';
 import type { Logger } from '../../infra/log/types';
+import type { WaConnectionCode, WaDisconnectReason } from '../../protocol/stream';
 import { type WaStreamControlNodeResult } from '../../transport/stream/parse';
 import type { BinaryNode } from '../../transport/types';
 interface WaIncomingNodeRuntime {
@@ -31,7 +32,8 @@ interface WaIncomingNodeRuntime {
     readonly emitGroupEvent: (event: WaGroupEvent) => void;
     readonly emitUnhandledIncomingNode: (event: WaIncomingUnhandledStanzaEvent) => void;
     readonly syncAppState: () => Promise<void>;
-    readonly disconnect: () => Promise<void>;
+    readonly stopComms: () => void;
+    readonly disconnect: (reason: WaDisconnectReason, isLogout: boolean, code: WaConnectionCode | null) => Promise<void>;
     readonly clearStoredCredentials: () => Promise<void>;
     readonly parseDirtyBits: (nodes: readonly BinaryNode[]) => readonly WaDirtyBit[];
     readonly handleDirtyBits: (dirtyBits: readonly WaDirtyBit[]) => Promise<void>;

package/dist/types/client/coordinators/WaMessageDispatchCoordinator.d.ts

@@ -11,6 +11,8 @@ import type { OutboundRetryTracker } from '../../retry/tracker';
 import type { SenderKeyManager } from '../../signal/group/SenderKeyManager';
 import type { SignalSessionResolver } from '../../signal/session/resolver';
 import type { SignalProtocol } from '../../signal/session/SignalProtocol';
+import type { WaDeviceListStore } from '../../store/contracts/device-list.store';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
 import type { BinaryNode } from '../../transport/types';
 interface WaMessageDispatchCoordinatorOptions {
     readonly logger: Logger;
@@ -23,9 +25,13 @@ interface WaMessageDispatchCoordinatorOptions {
     readonly buildMessageContent: (content: WaSendMessageContent) => Promise<Proto.IMessage>;
     readonly senderKeyManager: SenderKeyManager;
     readonly signalProtocol: SignalProtocol;
+    readonly signalStore: WaSignalStore;
+    readonly deviceListStore: WaDeviceListStore;
     readonly getCurrentMeJid: () => string | null | undefined;
     readonly getCurrentMeLid: () => string | null | undefined;
     readonly getCurrentSignedIdentity: () => Proto.IADVSignedDeviceIdentity | null | undefined;
+    readonly resolvePrivacyTokenNode: (recipientJid: string) => Promise<BinaryNode | null>;
+    readonly onDirectMessageSent: (recipientJid: string) => void;
 }
 export declare class WaMessageDispatchCoordinator {
     private readonly logger;
@@ -38,9 +44,16 @@ export declare class WaMessageDispatchCoordinator {
     private readonly buildMessageContent;
     private readonly senderKeyManager;
     private readonly signalProtocol;
+    private readonly signalStore;
+    private readonly deviceListStore;
     private readonly getCurrentMeJid;
     private readonly getCurrentMeLid;
     private readonly getCurrentSignedIdentity;
+    private readonly resolvePrivacyTokenNode;
+    private readonly onDirectMessageSent;
+    private readonly icdcDedup;
+    private readonly privacyTokenDedup;
+    private readonly distributionDedup;
     constructor(options: WaMessageDispatchCoordinatorOptions);
     publishMessageNode(node: BinaryNode, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
     publishEncryptedMessage(input: WaEncryptedMessageInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
@@ -62,6 +75,7 @@ export declare class WaMessageDispatchCoordinator {
     private generateOutgoingMessageId;
     private tryBuildReportingTokenArtifacts;
     private getEncodedSignedDeviceIdentity;
+    private resolveUserIcdc;
     private requireCurrentMeJid;
 }
 export {};

package/dist/types/client/coordinators/WaPassiveTasksCoordinator.d.ts

@@ -32,11 +32,15 @@ export declare class WaPassiveTasksCoordinator {
         readonly runtime: WaPassiveTasksRuntime;
     });
     startPassiveTasksAfterConnect(): void;
+    handlePreKeyLowNotification(): Promise<void>;
+    handleDigestNotification(): Promise<void>;
     resetInFlightState(): void;
     private runPassiveTasksAfterConnect;
     private validateDigestAndRecoverPreKeys;
     private uploadPreKeysIfMissing;
     private rotateSignedPreKeyIfDue;
+    private resolveLocalKeyBundle;
+    private resolveLocalKeyBundleFromStore;
     private resolveRotationTimestamp;
     private flushDanglingReceipts;
 }

package/dist/types/client/coordinators/WaPrivacyCoordinator.d.ts

@@ -0,0 +1,26 @@
+import type { WaPrivacyDisallowedListSettingName, WaPrivacySettingName, WaPrivacySettingValueMap } from '../../protocol/privacy';
+import type { BinaryNode } from '../../transport/types';
+export type WaPrivacySettings = {
+    readonly [K in WaPrivacySettingName]?: WaPrivacySettingValueMap[K];
+};
+export interface WaPrivacyDisallowedListResult {
+    readonly jids: readonly string[];
+    readonly dhash?: string;
+}
+export interface WaBlocklistResult {
+    readonly jids: readonly string[];
+    readonly dhash?: string;
+}
+export interface WaPrivacyCoordinator {
+    readonly getPrivacySettings: () => Promise<WaPrivacySettings>;
+    readonly setPrivacySetting: <S extends WaPrivacySettingName>(setting: S, value: WaPrivacySettingValueMap[S]) => Promise<void>;
+    readonly getDisallowedList: (category: WaPrivacyDisallowedListSettingName) => Promise<WaPrivacyDisallowedListResult>;
+    readonly getBlocklist: () => Promise<WaBlocklistResult>;
+    readonly blockUser: (jid: string) => Promise<void>;
+    readonly unblockUser: (jid: string) => Promise<void>;
+}
+interface WaPrivacyCoordinatorOptions {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+}
+export declare function createPrivacyCoordinator(options: WaPrivacyCoordinatorOptions): WaPrivacyCoordinator;
+export {};

package/dist/types/client/coordinators/WaProfileCoordinator.d.ts

@@ -0,0 +1,36 @@
+import type { WaProfilePictureType } from '../../transport/node/builders/profile';
+import type { BinaryNode } from '../../transport/types';
+export interface WaProfilePictureResult {
+    readonly url?: string;
+    readonly directPath?: string;
+    readonly id?: string;
+    readonly type?: string;
+}
+export interface WaProfileStatusResult {
+    readonly status: string | null;
+}
+export interface WaProfileInfo {
+    readonly jid: string;
+    readonly pictureId?: number;
+    readonly status?: string | null;
+}
+export interface WaDisappearingModeResult {
+    readonly duration: number;
+    readonly timestamp: number;
+    readonly ephemeralityDisabled?: boolean;
+}
+export interface WaProfileCoordinator {
+    readonly getProfilePicture: (jid: string, type?: WaProfilePictureType, existingId?: string) => Promise<WaProfilePictureResult>;
+    readonly setProfilePicture: (imageBytes: Uint8Array, targetJid?: string) => Promise<string | null>;
+    readonly deleteProfilePicture: (targetJid?: string) => Promise<void>;
+    readonly getStatus: (jid: string) => Promise<WaProfileStatusResult>;
+    readonly setStatus: (text: string) => Promise<void>;
+    readonly getProfiles: (jids: readonly string[]) => Promise<readonly WaProfileInfo[]>;
+    readonly getDisappearingMode: (jids: readonly string[]) => Promise<readonly WaDisappearingModeResult[]>;
+}
+interface WaProfileCoordinatorOptions {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly generateSid: () => Promise<string>;
+}
+export declare function createProfileCoordinator(options: WaProfileCoordinatorOptions): WaProfileCoordinator;
+export {};

package/dist/types/client/coordinators/WaRetryCoordinator.d.ts

@@ -38,6 +38,7 @@ export declare class WaRetryCoordinator {
     private readonly getCurrentMeLid;
     private readonly getCurrentSignedIdentity;
     private readonly retryProcessingByMessageId;
+    private readonly retrySessionBaseKeys;
     private nextRetryCleanupAtMs;
     constructor(options: WaRetryCoordinatorOptions);
     onDecryptFailure(context: WaRetryDecryptFailureContext, error: unknown): Promise<boolean>;
@@ -52,6 +53,7 @@ export declare class WaRetryCoordinator {
     private runRetryTaskSerialized;
     private buildRetryKeysSection;
     private updateLocalSessionFromRetryRequest;
+    private applySessionBaseKeyPolicy;
     private markRetryRequesterSenderKeyAsStale;
     private fetchMissingPreKeysSession;
     private authorizeRetryRequest;
@@ -59,5 +61,9 @@ export declare class WaRetryCoordinator {
     private mapOutboundStateFromReceiptType;
     private sendRetryAckSafe;
     private maybeCleanupRetryStore;
+    private retrySessionBaseKeyMapKey;
+    private setRetrySessionBaseKey;
+    private getRetrySessionBaseKey;
+    private cleanupRetrySessionBaseKeys;
 }
 export {};

package/dist/types/client/coordinators/WaStreamControlCoordinator.d.ts

@@ -1,4 +1,5 @@
 import type { Logger } from '../../infra/log/types';
+import type { WaConnectionCode, WaConnectionOpenReason, WaDisconnectReason } from '../../protocol/stream';
 import type { WaStreamControlNodeResult } from '../../transport/stream/parse';
 import type { WaComms } from '../../transport/WaComms';
 interface WaStreamControlCoordinatorOptions {
@@ -6,9 +7,9 @@ interface WaStreamControlCoordinatorOptions {
     readonly getComms: () => WaComms | null;
     readonly clearPendingQueries: (error: Error) => void;
     readonly clearMediaConnCache: () => void;
-    readonly disconnect: () => Promise<void>;
+    readonly disconnect: (reason: WaDisconnectReason, isLogout: boolean, code: WaConnectionCode | null) => Promise<void>;
     readonly clearStoredCredentials: () => Promise<void>;
-    readonly connect: () => Promise<void>;
+    readonly connect: (reason: WaConnectionOpenReason) => Promise<void>;
 }
 export interface WaStreamControlHandler {
     readonly handleStreamControlResult: (result: WaStreamControlNodeResult) => Promise<void>;

package/dist/types/client/coordinators/WaTrustedContactTokenCoordinator.d.ts

@@ -0,0 +1,45 @@
+import type { ParsedPrivacyToken } from '../events/privacy-token';
+import type { WaClientEventMap } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaPrivacyTokenStore } from '../../store/contracts/privacy-token.store';
+import type { BinaryNode } from '../../transport/types';
+type WaTrustedContactTokenRuntime = {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
+    readonly getCurrentMeLid: () => string | null;
+};
+export declare class WaTrustedContactTokenCoordinator {
+    private readonly logger;
+    private readonly store;
+    private readonly runtime;
+    private readonly config;
+    private readonly csTokenGenerator;
+    private readonly senderTokenDedup;
+    private cachedNctSalt;
+    private nctSaltHydrated;
+    constructor(options: {
+        readonly logger: Logger;
+        readonly store: WaPrivacyTokenStore;
+        readonly runtime: WaTrustedContactTokenRuntime;
+        readonly durationS?: number;
+        readonly numBuckets?: number;
+        readonly senderDurationS?: number;
+        readonly senderNumBuckets?: number;
+        readonly maxDurationS?: number;
+    });
+    resolveTokenForMessage(recipientJid: string): Promise<BinaryNode | null>;
+    handleIncomingToken(fromJid: string, tokens: readonly ParsedPrivacyToken[]): Promise<void>;
+    maybeIssueSenderToken(recipientJid: string): Promise<void>;
+    reissueOnIdentityChange(jid: string): Promise<void>;
+    hydrateFromHistorySync(conversations: readonly {
+        readonly jid: string;
+        readonly tcToken?: Uint8Array | null;
+        readonly tcTokenTimestamp?: number | null;
+        readonly tcTokenSenderTimestamp?: number | null;
+    }[]): Promise<void>;
+    handleNctSaltSync(salt: Uint8Array | null): Promise<void>;
+    hydrateNctSaltFromHistorySync(salt: Uint8Array): Promise<void>;
+    private getNctSalt;
+    private issuePrivacyToken;
+}
+export {};

package/dist/types/client/events/devices.d.ts

@@ -0,0 +1,20 @@
+import type { BinaryNode } from '../../transport/types';
+export declare const DEVICE_NOTIFICATION_ACTIONS: Readonly<{
+    readonly ADD: "add";
+    readonly REMOVE: "remove";
+    readonly UPDATE: "update";
+}>;
+export type DeviceNotificationAction = (typeof DEVICE_NOTIFICATION_ACTIONS)[keyof typeof DEVICE_NOTIFICATION_ACTIONS];
+export interface DeviceNotificationDevice {
+    readonly deviceId: number;
+    readonly keyIndex: number | null;
+}
+export interface DeviceNotification {
+    readonly action: DeviceNotificationAction;
+    readonly stanzaId: string;
+    readonly fromJid: string;
+    readonly lid: string | undefined;
+    readonly hash: string | undefined;
+    readonly devices: readonly DeviceNotificationDevice[];
+}
+export declare function parseDeviceNotification(node: BinaryNode): DeviceNotification | null;

package/dist/types/client/events/identity.d.ts

@@ -0,0 +1,9 @@
+import type { BinaryNode } from '../../transport/types';
+export interface IdentityChangeNotification {
+    readonly fromJid: string;
+    readonly stanzaId: string;
+    readonly displayName: string | undefined;
+    readonly lid: string | undefined;
+    readonly offline: string | undefined;
+}
+export declare function parseIdentityChangeNotification(node: BinaryNode): IdentityChangeNotification | null;

package/dist/types/client/events/privacy-token.d.ts

@@ -0,0 +1,7 @@
+import type { BinaryNode } from '../../transport/types';
+export interface ParsedPrivacyToken {
+    readonly type: string;
+    readonly tokenBytes: Uint8Array;
+    readonly timestampS: number;
+}
+export declare function parsePrivacyTokenNotification(node: BinaryNode): readonly ParsedPrivacyToken[];

package/dist/types/client/history-sync.d.ts

@@ -1,17 +1,20 @@
+import type { WriteBehindPersistence } from './persistence/WriteBehindPersistence';
 import type { WaClientEventMap } from './types';
 import type { Logger } from '../infra/log/types';
 import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import { type Proto } from '..';
-import type { WaContactStore } from '../store/contracts/contact.store';
-import type { WaMessageStore } from '../store/contracts/message.store';
-import type { WaThreadStore } from '../store/contracts/thread.store';
 interface WaHistorySyncDeps {
     readonly logger: Logger;
     readonly mediaTransfer: WaMediaTransferClient;
-    readonly contactStore: WaContactStore;
-    readonly messageStore: WaMessageStore;
-    readonly threadStore: WaThreadStore;
+    readonly writeBehind: WriteBehindPersistence;
     readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
+    readonly onPrivacyTokens?: (conversations: readonly {
+        readonly jid: string;
+        readonly tcToken?: Uint8Array | null;
+        readonly tcTokenTimestamp?: number | null;
+        readonly tcTokenSenderTimestamp?: number | null;
+    }[]) => Promise<void>;
+    readonly onNctSalt?: (salt: Uint8Array) => Promise<void>;
 }
 export declare function processHistorySyncNotification(deps: WaHistorySyncDeps, notification: Proto.Message.IHistorySyncNotification): Promise<void>;
 export {};

package/dist/types/client/incoming.d.ts

@@ -1,5 +1,6 @@
 import type { WaIncomingBaseEvent, WaIncomingFailureEvent, WaIncomingNotificationEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent, WaGroupEvent } from './types';
 import type { Logger } from '../infra/log/types';
+import type { WaConnectionCode, WaDisconnectReason } from '../protocol/stream';
 import type { BinaryNode } from '../transport/types';
 interface IncomingAckRuntime {
     readonly logger: Logger;
@@ -13,7 +14,8 @@ type IncomingReceiptHandlerOptions = IncomingAckRuntime & {
 type IncomingFailureHandlerOptions = {
     readonly logger: Logger;
     readonly emitIncomingFailure: (event: WaIncomingFailureEvent) => void;
-    readonly disconnect: () => Promise<void>;
+    readonly stopComms: () => void;
+    readonly disconnect: (reason: WaDisconnectReason, isLogout: boolean, code: WaConnectionCode | null) => Promise<void>;
     readonly clearStoredCredentials: () => Promise<void>;
 };
 type IncomingNotificationHandlerOptions = IncomingAckRuntime & {

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

@@ -1,2 +1,2 @@
 export { WaClient } from './WaClient';
-export type { WaAppStateMessageKey, WaClientProxyOptions, WaClearChatOptions, WaChatEvent, WaChatEventAction, WaChatEventSource, WaClientEventMap, WaClientOptions, WaDeleteChatOptions, WaDeleteMessageForMeOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from './types';
+export type { WaAppStateMessageKey, WaClientProxyOptions, WaClearChatOptions, WaChatEvent, WaChatEventAction, WaChatEventSource, WaClientEventMap, WaClientOptions, WaConnectionEvent, WaDeleteChatOptions, WaDeleteMessageForMeOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions, WaLogoutStoreClearOptions, WaWriteBehindOptions } from './types';

package/dist/types/client/mailbox.d.ts

@@ -1,12 +1,10 @@
+import type { WriteBehindPersistence } from './persistence/WriteBehindPersistence';
 import type { WaIncomingMessageEvent } from './types';
 import type { Logger } from '../infra/log/types';
-import type { WaContactStore } from '../store/contracts/contact.store';
-import type { WaMessageStore } from '../store/contracts/message.store';
 interface WaPersistIncomingMailboxOptions {
     readonly logger: Logger;
-    readonly contactStore: WaContactStore;
-    readonly messageStore: WaMessageStore;
+    readonly writeBehind: WriteBehindPersistence;
     readonly event: WaIncomingMessageEvent;
 }
-export declare function persistIncomingMailboxEntities(options: WaPersistIncomingMailboxOptions): Promise<void>;
+export declare function persistIncomingMailboxEntities(options: WaPersistIncomingMailboxOptions): void;
 export {};

package/dist/types/client/messages.d.ts

@@ -4,7 +4,7 @@ import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import type { WaSendMessageContent } from '../message/types';
 import type { Proto } from '..';
 import type { BinaryNode } from '../transport/types';
-interface WaMediaMessageOptions {
+export interface WaMediaMessageOptions {
     readonly logger: Logger;
     readonly mediaTransfer: WaMediaTransferClient;
     readonly iqTimeoutMs?: number;
@@ -14,4 +14,3 @@ interface WaMediaMessageOptions {
 }
 export declare function buildMediaMessageContent(options: WaMediaMessageOptions, content: WaSendMessageContent): Promise<Proto.IMessage>;
 export declare function getMediaConn(options: WaMediaMessageOptions, forceRefresh?: boolean): Promise<WaMediaConn>;
-export {};

package/dist/types/client/persistence/WriteBehindPersistence.d.ts

@@ -0,0 +1,34 @@
+import type { WaWriteBehindOptions } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { BackgroundQueueFlushResult } from '../../infra/perf/BackgroundQueue';
+import type { WaContactStore, WaStoredContactRecord } from '../../store/contracts/contact.store';
+import type { WaMessageStore, WaStoredMessageRecord } from '../../store/contracts/message.store';
+import type { WaStoredThreadRecord, WaThreadStore } from '../../store/contracts/thread.store';
+interface WriteBehindStores {
+    readonly messageStore: WaMessageStore;
+    readonly threadStore: WaThreadStore;
+    readonly contactStore: WaContactStore;
+}
+export interface WriteBehindDrainResult {
+    readonly messages: BackgroundQueueFlushResult;
+    readonly threads: BackgroundQueueFlushResult;
+    readonly contacts: BackgroundQueueFlushResult;
+    readonly flushed: number;
+    readonly remaining: number;
+}
+export declare class WriteBehindPersistence {
+    private readonly logger;
+    private readonly queues;
+    private readonly flushTimeoutMs;
+    constructor(stores: WriteBehindStores, logger: Logger, options?: WaWriteBehindOptions);
+    persistMessage(record: WaStoredMessageRecord): void;
+    persistMessageAsync(record: WaStoredMessageRecord): Promise<void>;
+    persistThread(record: WaStoredThreadRecord): void;
+    persistThreadAsync(record: WaStoredThreadRecord): Promise<void>;
+    persistContact(record: WaStoredContactRecord): void;
+    persistContactAsync(record: WaStoredContactRecord): Promise<void>;
+    flush(timeoutMs?: number): Promise<WriteBehindDrainResult>;
+    destroy(timeoutMs?: number): Promise<WriteBehindDrainResult>;
+    private toDrainResult;
+}
+export {};

package/dist/types/client/tokens/cs-token.d.ts

@@ -0,0 +1,10 @@
+export declare class CsTokenGenerator {
+    private cachedKey;
+    private cachedSalt;
+    private readonly cache;
+    constructor();
+    generate(nctSalt: Uint8Array, accountLid: string): Promise<Uint8Array>;
+    invalidate(): void;
+    private isSameSalt;
+    private resolveKey;
+}