zapo-js 0.1.2 → 0.3.0

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

@@ -0,0 +1,31 @@
+import type { WaOfflineResumeEvent } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { BinaryNode } from '../../transport/types';
+interface WaOfflineResumeRuntime {
+    readonly sendNode: (node: BinaryNode) => Promise<void>;
+    readonly emitOfflineResume: (event: WaOfflineResumeEvent) => void;
+}
+interface WaOfflineResumeCoordinatorOptions {
+    readonly logger: Logger;
+    readonly runtime: WaOfflineResumeRuntime;
+}
+export declare class WaOfflineResumeCoordinator {
+    private readonly logger;
+    private readonly runtime;
+    private state;
+    private totalStanzas;
+    private pendingStanzas;
+    private stanzaTimeout;
+    constructor(options: WaOfflineResumeCoordinatorOptions);
+    get isComplete(): boolean;
+    get isResuming(): boolean;
+    handleOfflinePreview(stanzaCount: number): void;
+    handleOfflineComplete(serverStanzaCount: number): void;
+    trackOfflineStanza(): void;
+    reset(): void;
+    private completeResume;
+    private sendOfflineBatch;
+    private resetStanzaTimeout;
+    private clearTimers;
+}
+export {};

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

@@ -1,42 +1,57 @@
+import type { WaAppStateSyncClient } from '../../appstate/WaAppStateSyncClient';
 import type { WaAuthCredentials } from '../../auth/types';
 import type { Logger } from '../../infra/log/types';
 import type { SignalDigestSyncApi } from '../../signal/api/SignalDigestSyncApi';
 import type { SignalRotateKeyApi } from '../../signal/api/SignalRotateKeyApi';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 import type { BinaryNode } from '../../transport/types';
 type WaPassiveTasksRuntime = {
-    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>, options?: {
+        readonly useSystemId?: boolean;
+    }) => Promise<BinaryNode>;
     readonly getCurrentCredentials: () => WaAuthCredentials | null;
     readonly persistServerHasPreKeys: (serverHasPreKeys: boolean) => Promise<void>;
     readonly sendNodeDirect: (node: BinaryNode) => Promise<void>;
     readonly takeDanglingReceipts: () => BinaryNode[];
     readonly requeueDanglingReceipt: (node: BinaryNode) => void;
     readonly shouldQueueDanglingReceipt: (node: BinaryNode, error: Error) => boolean;
+    readonly syncAbProps: () => void;
+    readonly sendPresenceAvailable: () => Promise<void>;
 };
 export declare class WaPassiveTasksCoordinator {
     private readonly logger;
     private readonly signalStore;
+    private readonly preKeyStore;
     private readonly signalDigestSync;
     private readonly signalRotateKey;
     private readonly signedPreKeyRotationIntervalMs;
     private readonly signedPreKeyServerErrorBackoffMs;
     private readonly runtime;
+    private readonly mobilePrimary;
+    private readonly appStateSync?;
     private passiveTasksPromise;
     constructor(options: {
         readonly logger: Logger;
         readonly signalStore: WaSignalStore;
+        readonly preKeyStore: WaPreKeyStore;
         readonly signalDigestSync: SignalDigestSyncApi;
         readonly signalRotateKey: SignalRotateKeyApi;
         readonly signedPreKeyRotationIntervalMs?: number;
         readonly signedPreKeyServerErrorBackoffMs?: number;
         readonly runtime: WaPassiveTasksRuntime;
+        readonly mobilePrimary?: boolean;
+        readonly appStateSync?: WaAppStateSyncClient;
     });
     startPassiveTasksAfterConnect(): void;
+    handlePreKeyLowNotification(): Promise<void>;
+    handleDigestNotification(): Promise<void>;
     resetInFlightState(): void;
     private runPassiveTasksAfterConnect;
     private validateDigestAndRecoverPreKeys;
     private uploadPreKeysIfMissing;
     private rotateSignedPreKeyIfDue;
+    private resolveLocalKeyBundleFromStore;
     private resolveRotationTimestamp;
     private flushDanglingReceipts;
 }

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

@@ -0,0 +1,26 @@
+import { type WaPrivacyDisallowedListSettingName, type WaPrivacySettingName, type 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,38 @@
+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>>, options?: {
+        readonly useSystemId?: boolean;
+    }) => Promise<BinaryNode>;
+    readonly generateSid: () => Promise<string>;
+}
+export declare function createProfileCoordinator(options: WaProfileCoordinatorOptions): WaProfileCoordinator;
+export {};

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

@@ -5,14 +5,18 @@ import type { WaRetryDecryptFailureContext } from '../../retry/types';
 import type { SignalDeviceSyncApi } from '../../signal/api/SignalDeviceSyncApi';
 import type { SignalMissingPreKeysSyncApi } from '../../signal/api/SignalMissingPreKeysSyncApi';
 import type { SignalProtocol } from '../../signal/session/SignalProtocol';
+import type { WaPreKeyStore } from '../../store/contracts/pre-key.store';
 import type { WaRetryStore } from '../../store/contracts/retry.store';
 import type { WaSenderKeyStore } from '../../store/contracts/sender-key.store';
+import type { WaSessionStore } from '../../store/contracts/session.store';
 import type { WaSignalStore } from '../../store/contracts/signal.store';
 import type { BinaryNode } from '../../transport/types';
 interface WaRetryCoordinatorOptions {
     readonly logger: Logger;
     readonly retryStore: WaRetryStore;
     readonly signalStore: WaSignalStore;
+    readonly preKeyStore: WaPreKeyStore;
+    readonly sessionStore: WaSessionStore;
     readonly senderKeyStore: WaSenderKeyStore;
     readonly signalProtocol: SignalProtocol;
     readonly signalDeviceSync: SignalDeviceSyncApi;
@@ -28,6 +32,8 @@ export declare class WaRetryCoordinator {
     private readonly retryStore;
     private readonly retryTtlMs;
     private readonly signalStore;
+    private readonly preKeyStore;
+    private readonly sessionStore;
     private readonly senderKeyStore;
     private readonly signalProtocol;
     private readonly signalDeviceSync;
@@ -38,6 +44,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 +59,7 @@ export declare class WaRetryCoordinator {
     private runRetryTaskSerialized;
     private buildRetryKeysSection;
     private updateLocalSessionFromRetryRequest;
+    private applySessionBaseKeyPolicy;
     private markRetryRequesterSenderKeyAsStale;
     private fetchMissingPreKeysSession;
     private authorizeRetryRequest;
@@ -59,5 +67,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,55 @@
+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;
+};
+interface WaTrustedContactTokenConfig {
+    readonly durationS: number;
+    readonly numBuckets: number;
+    readonly senderDurationS: number;
+    readonly senderNumBuckets: number;
+    readonly maxDurationS: number;
+}
+export declare class WaTrustedContactTokenCoordinator {
+    private readonly logger;
+    private readonly store;
+    private readonly runtime;
+    private readonly baseConfig;
+    private readonly getConfigOverrides;
+    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;
+        readonly getConfigOverrides?: () => Partial<WaTrustedContactTokenConfig>;
+    });
+    private resolveConfig;
+    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/dirty.d.ts

@@ -8,7 +8,9 @@ export interface WaDirtyBit {
 }
 interface WaDirtySyncRuntime {
     readonly logger: Logger;
-    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>, options?: {
+        readonly useSystemId?: boolean;
+    }) => Promise<BinaryNode>;
     readonly getCurrentCredentials: () => WaAuthCredentials | null;
     readonly syncAppState: () => Promise<void>;
     readonly generateUsyncSid: () => Promise<string>;

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

@@ -0,0 +1,14 @@
+import type { BinaryNode } from '../../transport/types';
+export interface AbPropResponseEntry {
+    readonly configCode: number;
+    readonly configValue: string | null;
+}
+export interface AbPropSyncResult {
+    readonly abKey: string | null;
+    readonly hash: string | null;
+    readonly refresh: number | null;
+    readonly refreshId: number | null;
+    readonly isDeltaUpdate: boolean;
+    readonly props: readonly AbPropResponseEntry[];
+}
+export declare function parseAbPropsIqResult(node: BinaryNode): AbPropSyncResult;

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

@@ -0,0 +1,17 @@
+import type { BinaryNode } from '../../transport/types';
+export interface ParsedRegistrationCode {
+    readonly kind: 'registration_code';
+    readonly code: string;
+    readonly expiryTimestampMs: number;
+    readonly fromDeviceId: string;
+}
+export interface ParsedAccountTakeoverNotice {
+    readonly kind: 'account_takeover_notice';
+    readonly serverToken: string;
+    readonly attemptTimestampMs: number;
+    readonly newDeviceName?: string;
+    readonly newDevicePlatform?: string;
+    readonly newDeviceAppVersion?: string;
+}
+export type ParsedRegistrationNotification = ParsedRegistrationCode | ParsedAccountTakeoverNotice | null;
+export declare function parseRegistrationNotification(node: BinaryNode): ParsedRegistrationNotification;

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 { WaAccountTakeoverNoticeEvent, WaGroupEvent, WaIncomingBaseEvent, WaIncomingFailureEvent, WaIncomingNotificationEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent, WaRegistrationCodeEvent } 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 & {
@@ -25,10 +27,15 @@ type IncomingGroupNotificationHandlerOptions = IncomingAckRuntime & {
     readonly emitGroupEvent: (event: WaGroupEvent) => void;
     readonly emitUnhandledStanza: (event: WaIncomingUnhandledStanzaEvent) => void;
 };
+type IncomingRegistrationNotificationHandlerOptions = IncomingAckRuntime & {
+    readonly emitRegistrationCode: (event: WaRegistrationCodeEvent) => void;
+    readonly emitAccountTakeoverNotice: (event: WaAccountTakeoverNoticeEvent) => void;
+};
 export declare function createIncomingBaseEvent(node: BinaryNode): WaIncomingBaseEvent;
 export declare function createIncomingReceiptHandler(options: IncomingReceiptHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingFailureHandler(options: IncomingFailureHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingNotificationHandler(options: IncomingNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
+export declare function createIncomingRegistrationNotificationHandler(options: IncomingRegistrationNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createIncomingGroupNotificationHandler(options: IncomingGroupNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
 export declare function createInfoBulletinNotificationEvent(node: BinaryNode, type: string, details?: Readonly<Record<string, unknown>>): WaIncomingNotificationEvent;
 export declare function createUnhandledIncomingNodeEvent(node: BinaryNode, reason?: string): WaIncomingUnhandledStanzaEvent;

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,12 @@
+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';
+import type { WaMessageSecretStore } from '../store/contracts/message-secret.store';
 interface WaPersistIncomingMailboxOptions {
     readonly logger: Logger;
-    readonly contactStore: WaContactStore;
-    readonly messageStore: WaMessageStore;
+    readonly writeBehind: WriteBehindPersistence;
+    readonly messageSecretStore: WaMessageSecretStore;
     readonly event: WaIncomingMessageEvent;
 }
-export declare function persistIncomingMailboxEntities(options: WaPersistIncomingMailboxOptions): Promise<void>;
+export declare function persistIncomingMailboxEntities(options: WaPersistIncomingMailboxOptions): void;
 export {};

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

@@ -0,0 +1,31 @@
+import type { Readable } from 'node:stream';
+import type { WaMediaOptions } from './types';
+import type { Logger } from '../infra/log/types';
+import type { WaSendMediaMessage } from '../message/types';
+export interface ProcessedMediaFields {
+    readonly jpegThumbnail?: Uint8Array;
+    readonly pngThumbnail?: Uint8Array;
+    readonly width?: number;
+    readonly height?: number;
+    readonly seconds?: number;
+    readonly waveform?: Uint8Array;
+    readonly isAnimated?: boolean;
+    readonly firstFrameLength?: number;
+}
+export declare function readFileHead(filePath: string, bytes: number): Promise<Uint8Array>;
+interface WebpAnimInfo {
+    readonly isAnimated: true;
+    readonly firstFrameLength: number;
+}
+export declare function parseWebpAnimation(data: Uint8Array): WebpAnimInfo | null;
+export declare function isReadableStream(value: unknown): value is Readable;
+export declare function cleanupTempFile(filePath: string): Promise<void>;
+export interface ResolvedMediaInputs {
+    readonly processorInput?: Uint8Array | string;
+    readonly uploadMedia: Uint8Array | Readable;
+    readonly tempFilePath?: string;
+}
+export declare function resolveMediaInputs(shouldProcess: boolean, raw: Uint8Array | ArrayBuffer | Readable | string): Promise<ResolvedMediaInputs>;
+export declare function hasMediaProcessingTasks(media: WaMediaOptions | undefined, content: WaSendMediaMessage): boolean;
+export declare function runMediaProcessor(media: WaMediaOptions | undefined, input: Uint8Array | string | undefined, content: WaSendMediaMessage, logger: Logger): Promise<ProcessedMediaFields>;
+export {};

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

@@ -1,17 +1,18 @@
+import type { WaMediaOptions } from './types';
 import type { Logger } from '../infra/log/types';
 import type { WaMediaConn } from '../media/types';
 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;
     readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
     readonly getMediaConnCache: () => WaMediaConn | null;
     readonly setMediaConnCache: (mediaConn: WaMediaConn | null) => void;
+    readonly media?: WaMediaOptions;
 }
 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;
+}

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

@@ -0,0 +1,5 @@
+export declare function computeBucket(unixTimeS: number, durationS: number): number;
+export declare function tokenExpirationCutoffS(nowS: number, durationS: number, numBuckets: number): number;
+export declare function isTokenExpired(tokenTimestampS: number, nowS: number, durationS: number, numBuckets: number): boolean;
+export declare function shouldSendNewToken(senderTimestampS: number, nowS: number, senderDurationS: number): boolean;
+export declare function clampDuration(durationS: number, maxDurationS: number): number;