zapo-js 0.1.2 → 0.3.0

package/dist/types/auth/WaAuthClient.d.ts

@@ -1,12 +1,14 @@
 import type { WaAuthClientOptions, WaAuthCredentials, WaAuthSocketOptions, WaSuccessPersistAttributes } from './types';
 import type { Logger } from '../infra/log/types';
 import type { WaAuthStore } from '../store/contracts/auth.store';
+import type { WaPreKeyStore } from '../store/contracts/pre-key.store';
 import type { WaSignalStore } from '../store/contracts/signal.store';
-import type { BinaryNode } from '../transport/types';
+import type { BinaryNode, WaNoiseTrustedRootCa } from '../transport/types';
 type WaAuthClientDeps = Readonly<{
     readonly logger: Logger;
     readonly authStore: WaAuthStore;
     readonly signalStore: WaSignalStore;
+    readonly preKeyStore: WaPreKeyStore;
     readonly socket: {
         readonly sendNode: (node: BinaryNode) => Promise<void>;
         readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
@@ -25,6 +27,7 @@ export declare class WaAuthClient {
     private readonly callbacks;
     private readonly authStore;
     private readonly signalStore;
+    private readonly preKeyStore;
     private readonly qrFlow;
     private readonly pairingFlow;
     private credentials;
@@ -37,7 +40,10 @@ export declare class WaAuthClient {
     };
     getCurrentCredentials(): WaAuthCredentials | null;
     loadOrCreateCredentials(): Promise<WaAuthCredentials>;
-    buildCommsConfig(socketOptions: WaAuthSocketOptions): import("../transport/types").WaCommsConfig;
+    buildCommsConfig(socketOptions: WaAuthSocketOptions, overrides?: {
+        readonly noiseTrustedRootCa?: WaNoiseTrustedRootCa;
+        readonly disableNoiseCertificateChainVerification?: boolean;
+    }): import("../transport/types").WaCommsConfig;
     clearTransientState(): Promise<void>;
     clearStoredCredentials(): Promise<void>;
     persistServerStaticKey(serverStaticKey: Uint8Array): Promise<void>;
@@ -45,7 +51,7 @@ export declare class WaAuthClient {
     persistRoutingInfo(routingInfo: Uint8Array): Promise<void>;
     clearRoutingInfo(): Promise<WaAuthCredentials>;
     persistSuccessAttributes(attributes: WaSuccessPersistAttributes): Promise<void>;
-    requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean): Promise<string>;
+    requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean, customCode?: string): Promise<string>;
     fetchPairingCountryCodeIso(): Promise<string>;
     handleIncomingIqSet(node: BinaryNode): Promise<boolean>;
     handleLinkCodeNotification(node: BinaryNode): Promise<boolean>;

package/dist/types/auth/credentials-flow.d.ts

@@ -0,0 +1,20 @@
+import type { WaAuthClientOptions, WaAuthCredentials, WaAuthSocketOptions } from './types';
+import type { Logger } from '../infra/log/types';
+import type { WaAuthStore } from '../store/contracts/auth.store';
+import type { WaPreKeyStore } from '../store/contracts/pre-key.store';
+import type { WaSignalStore } from '../store/contracts/signal.store';
+import type { WaCommsConfig, WaNoiseTrustedRootCa } from '../transport/types';
+interface WaAuthCredentialsFlowArgs {
+    readonly logger: Logger;
+    readonly authStore: WaAuthStore;
+    readonly signalStore: WaSignalStore;
+    readonly preKeyStore: WaPreKeyStore;
+    readonly skipSignedPreKeySignatureVerification?: boolean;
+}
+export declare function loadOrCreateCredentials(args: WaAuthCredentialsFlowArgs): Promise<WaAuthCredentials>;
+export declare function persistCredentials(args: WaAuthCredentialsFlowArgs, credentials: WaAuthCredentials): Promise<void>;
+export declare function buildCommsConfig(logger: Logger, credentials: WaAuthCredentials, socketOptions: WaAuthSocketOptions, clientOptions: Pick<WaAuthClientOptions, 'deviceBrowser' | 'deviceOsDisplayName' | 'requireFullSync' | 'version' | 'mobileTransport'> & {
+    readonly noiseTrustedRootCa?: WaNoiseTrustedRootCa;
+    readonly disableNoiseCertificateChainVerification?: boolean;
+}): WaCommsConfig;
+export {};

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

@@ -1,4 +1,2 @@
 export * from './types';
 export { WaAuthClient } from './WaAuthClient';
-export { completeCompanionFinish, createCompanionHello } from './pairing/WaPairingCodeCrypto';
-export { WaAuthSqliteStore } from '../store/providers/sqlite/auth.store';

package/dist/types/auth/pairing/WaPairingFlow.d.ts

@@ -1,4 +1,4 @@
-import type { WaAuthCredentials } from '../types';
+import type { WaAuthCredentials, WaAuthDangerousOptions } from '../types';
 import type { Logger } from '../../infra/log/types';
 import type { BinaryNode } from '../../transport/types';
 interface WaPairingFlowOptions {
@@ -26,6 +26,7 @@ interface WaPairingFlowOptions {
         readonly emitPairingRefresh: (forceManual: boolean) => void;
         readonly emitPaired: (credentials: WaAuthCredentials) => void;
     };
+    readonly dangerous?: WaAuthDangerousOptions;
 }
 export declare class WaPairingFlow {
     private readonly opts;
@@ -33,7 +34,7 @@ export declare class WaPairingFlow {
     constructor(options: WaPairingFlowOptions);
     hasPairingSession(): boolean;
     clearSession(): void;
-    requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean): Promise<string>;
+    requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean, customCode?: string): Promise<string>;
     fetchPairingCountryCodeIso(): Promise<string>;
     handleIncomingIqSet(node: BinaryNode): Promise<boolean>;
     handleLinkCodeNotification(node: BinaryNode): Promise<boolean>;

package/dist/types/auth/pairing/{WaPairingCodeCrypto.d.ts → pairing-code-crypto.d.ts}

@@ -1,5 +1,10 @@
 import type { SignalKeyPair } from '../../crypto/curves/types';
-export declare function createCompanionHello(): Promise<{
+export declare const CROCKFORD_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTVWXYZ";
+export declare const PBKDF2_ITERATIONS: number;
+export declare function normalizeCustomPairingCode(input: string): string;
+export declare function createCompanionHello(options?: {
+    readonly customCode?: string;
+}): Promise<{
     readonly pairingCode: string;
     readonly companionEphemeralKeyPair: SignalKeyPair;
     readonly wrappedCompanionEphemeralPub: Uint8Array;

package/dist/types/auth/types.d.ts

@@ -1,7 +1,9 @@
 import type { SignalKeyPair } from '../crypto/curves/types';
 import type { Proto } from '..';
 import type { RegistrationInfo, SignedPreKeyRecord } from '../signal/types';
+import type { WaMobileTransportDeviceInfo } from '../transport/noise/WaMobileClientPayload';
 import type { WaCommsConfig, WaProxyTransport } from '../transport/types';
+export type { WaMobileTransportDeviceInfo } from '../transport/noise/WaMobileClientPayload';
 export interface WaAuthCredentials {
     readonly noiseKeyPair: SignalKeyPair;
     readonly registrationInfo: RegistrationInfo;
@@ -21,6 +23,10 @@ export interface WaAuthCredentials {
     readonly abPropsVersion?: number;
     readonly connectionLocation?: string;
     readonly accountCreationTs?: number;
+    readonly deviceInfo?: WaMobileTransportDeviceInfo;
+    readonly pushName?: string;
+    readonly yearClass?: number;
+    readonly memClass?: number;
 }
 export type WaAuthSocketOptions = Pick<WaCommsConfig, 'url' | 'urls' | 'protocols' | 'connectTimeoutMs' | 'reconnectIntervalMs' | 'timeoutIntervalMs' | 'maxReconnectAttempts'> & {
     readonly proxy?: {
@@ -32,6 +38,41 @@ export interface WaAuthClientOptions {
     readonly devicePlatform?: string;
     readonly deviceOsDisplayName?: string;
     readonly requireFullSync?: boolean;
+    readonly version?: string;
+    readonly dangerous?: WaAuthDangerousOptions;
+    readonly mobileTransport?: WaMobileTransportOptions;
+}
+export interface WaMobileTransportOptions {
+    readonly deviceInfo: WaMobileTransportDeviceInfo;
+    readonly tcpUrl?: string;
+    readonly passive?: boolean;
+    readonly pushName?: string;
+    readonly yearClass?: number;
+    readonly memClass?: number;
+}
+export interface WaAuthDangerousOptions {
+    /**
+     * Skip the noise certificate-chain verification during the handshake.
+     * The server's static key will be accepted without proof that it was
+     * issued by a trusted root.
+     */
+    readonly disableNoiseCertificateChainVerification?: boolean;
+    /**
+     * Skip the XEdDSA account-signature check on the `pair-success` ADV
+     * identity payload, which normally proves the primary device signed off
+     * on this companion.
+     */
+    readonly disableAdvSignatureVerification?: boolean;
+    /**
+     * Skip the HMAC check on the `pair-success` stanza that ties the ADV
+     * payload to the shared pairing secret.
+     */
+    readonly disablePairSuccessHmacVerification?: boolean;
+    /**
+     * Skip the XEdDSA signature check on the locally stored signed pre-key
+     * during credential load. Corrupt or forged credentials will be accepted.
+     */
+    readonly disableSignedPreKeySignatureVerification?: boolean;
 }
 export interface WaSuccessPersistAttributes {
     readonly meLid?: string;

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

@@ -1,14 +1,20 @@
 import { EventEmitter } from 'node:events';
-import type { WaAppStateStoreData, WaAppStateSyncResult } from '../appstate/types';
-import type { WaAppStateSyncOptions } from '../appstate/types';
+import type { WaAppStateStoreData, WaAppStateSyncOptions, WaAppStateSyncResult } from '../appstate/types';
 import type { WaAppStateSyncClient } from '../appstate/WaAppStateSyncClient';
+import type { WaAppStateMutationCoordinator } from './coordinators/WaAppStateMutationCoordinator';
+import type { WaBusinessCoordinator } from './coordinators/WaBusinessCoordinator';
+import type { WaEmailCoordinator } from './coordinators/WaEmailCoordinator';
 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 { WaClientEventMap, WaClientOptions, WaIncomingNodeHandlerRegistration, WaSendMessageOptions } from './types';
 import type { Logger } from '../infra/log/types';
 import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
 import type { WaMessagePublishResult, WaSendMessageContent, WaSendReceiptInput } from '../message/types';
 import type { WaMessageClient } from '../message/WaMessageClient';
+import { type WaLogoutReason } from '../protocol/stream';
 import type { SignalLidSyncResult } from '../signal/api/SignalDeviceSyncApi';
 import type { BinaryNode } from '../transport/types';
 export declare class WaClient extends EventEmitter {
@@ -17,10 +23,15 @@ export declare class WaClient extends EventEmitter {
     private readonly appStateStore;
     private readonly contactStore;
     private readonly messageStore;
+    private readonly messageSecretStore;
     private readonly participantsStore;
+    private readonly privacyTokenStore;
     private readonly deviceListStore;
     private readonly retryStore;
     private readonly signalStore;
+    private readonly preKeyStore;
+    private readonly sessionStore;
+    private readonly identityStore;
     private readonly senderKeyStore;
     private readonly threadStore;
     private readonly authClient;
@@ -28,18 +39,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;
+    readonly emailCoordinator: WaEmailCoordinator;
     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;
@@ -55,14 +74,16 @@ export declare class WaClient extends EventEmitter {
         hasQr: boolean;
         hasPairingCode: boolean;
     };
-    getCredentials(): import("../auth").WaAuthCredentials | null;
+    getCredentials(): import("..").WaAuthCredentials | null;
     getClockSkewMs(): number | null;
     sendNode(node: BinaryNode): Promise<void>;
-    query(node: BinaryNode, timeoutMs?: number): Promise<BinaryNode>;
+    sendPresence(type?: 'available' | 'unavailable'): Promise<void>;
+    query(node: BinaryNode, timeoutMs?: number, options?: {
+        readonly useSystemId?: boolean;
+    }): Promise<BinaryNode>;
     registerIncomingHandler(registration: WaIncomingNodeHandlerRegistration): () => void;
     unregisterIncomingHandler(registration: WaIncomingNodeHandlerRegistration): boolean;
     private bindNodeTransportEvents;
-    private getMailboxPersistenceDeps;
     private handleIncomingMessageEvent;
     private handleIncomingAppStateSyncKeyShare;
     private handleIncomingAppStateSyncKeyRequest;
@@ -73,27 +94,32 @@ export declare class WaClient extends EventEmitter {
     private handleIncomingFrame;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean): Promise<string>;
+    requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean, customCode?: string): Promise<string>;
     fetchPairingCountryCodeIso(): Promise<string>;
     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;
+    get email(): WaEmailCoordinator;
+    logout(reason?: WaLogoutReason): Promise<void>;
     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 tryDecryptAddon;
+    private tryEnterIncomingHandler;
+    private leaveIncomingHandler;
+    private pauseIncomingEventsAndWaitDrain;
+    private notifyIncomingHandlersDrained;
     private handleError;
 }

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

@@ -2,16 +2,21 @@ import type { WaAppStateSyncOptions, WaAppStateSyncResult } from '../appstate/ty
 import { WaAppStateSyncClient } from '../appstate/WaAppStateSyncClient';
 import { WaAuthClient } from '../auth/WaAuthClient';
 import { WaConnectionManager } from './connection/WaConnectionManager';
-import { WaKeyShareCoordinator } from './connection/WaKeyShareCoordinator';
 import { WaReceiptQueue } from './connection/WaReceiptQueue';
+import { WaAbPropsCoordinator } from './coordinators/WaAbPropsCoordinator';
 import { WaAppStateMutationCoordinator } from './coordinators/WaAppStateMutationCoordinator';
+import { type WaBusinessCoordinator } from './coordinators/WaBusinessCoordinator';
+import { type WaEmailCoordinator } from './coordinators/WaEmailCoordinator';
 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 +33,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;
@@ -36,8 +40,12 @@ interface WaClientBase {
 }
 interface WaClientBuildRuntime {
     readonly sendNode: (node: BinaryNode) => Promise<void>;
-    readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
-    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly query: (node: BinaryNode, timeoutMs?: number, options?: {
+        readonly useSystemId?: boolean;
+    }) => Promise<BinaryNode>;
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>, options?: {
+        readonly useSystemId?: boolean;
+    }) => Promise<BinaryNode>;
     readonly syncAppState: () => Promise<void>;
     readonly syncAppStateWithOptions: (options?: WaAppStateSyncOptions) => Promise<WaAppStateSyncResult>;
     readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
@@ -45,13 +53,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 +74,19 @@ 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 emailCoordinator: WaEmailCoordinator;
     readonly receiptQueue: WaReceiptQueue;
-    readonly keyShareCoordinator: WaKeyShareCoordinator;
     readonly connectionManager: WaConnectionManager;
+    readonly trustedContactToken: WaTrustedContactTokenCoordinator;
+    readonly abPropsCoordinator: WaAbPropsCoordinator;
 }
 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/WaAbPropsCoordinator.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '../../infra/log/types';
+import { type AbPropName, type AbPropValue } from '../../protocol/abprops';
+import type { BinaryNode } from '../../transport/types';
+type WaAbPropsRuntime = {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+};
+export declare class WaAbPropsCoordinator {
+    private readonly logger;
+    private readonly runtime;
+    private readonly cache;
+    private readonly syncState;
+    private syncPromise;
+    private syncEpoch;
+    private pendingSync;
+    constructor(options: {
+        readonly logger: Logger;
+        readonly runtime: WaAbPropsRuntime;
+    });
+    getConfigValue<T extends AbPropValue>(name: AbPropName): T;
+    sync(): void;
+    reset(): void;
+    private startSync;
+    private executeSyncWithRetry;
+    private executeSync;
+}
+export {};

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

@@ -0,0 +1,24 @@
+import { type WaEmailContext } from '../../protocol/email';
+import { type BuildRequestEmailVerificationCodeInput } from '../../transport/node/builders/email';
+import type { BinaryNode } from '../../transport/types';
+export interface WaEmailStatus {
+    readonly email: string | null;
+    readonly verified: boolean;
+    readonly confirmed: boolean;
+}
+export interface WaEmailVerifyCodeResult {
+    readonly verified: boolean;
+    readonly autoVerifyFailed: boolean;
+    readonly email: string | null;
+}
+export interface WaEmailCoordinator {
+    readonly getStatus: () => Promise<WaEmailStatus>;
+    readonly setEmail: (email: string, context?: WaEmailContext) => Promise<WaEmailStatus>;
+    readonly requestVerificationCode: (input: BuildRequestEmailVerificationCodeInput) => Promise<void>;
+    readonly verifyCode: (code: string) => Promise<WaEmailVerifyCodeResult>;
+    readonly confirm: (context?: WaEmailContext) => Promise<void>;
+}
+export interface WaEmailCoordinatorOptions {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+}
+export declare function createEmailCoordinator(options: WaEmailCoordinatorOptions): WaEmailCoordinator;

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

@@ -1,7 +1,9 @@
 import type { WaSuccessPersistAttributes } from '../../auth/types';
+import type { WaOfflineResumeCoordinator } from '../coordinators/WaOfflineResumeCoordinator';
 import type { WaDirtyBit } from '../dirty';
-import type { WaIncomingBaseEvent, WaIncomingCallEvent, WaIncomingChatstateEvent, WaIncomingFailureEvent, WaGroupEvent, WaIncomingNodeHandlerRegistration, WaIncomingNotificationEvent, WaIncomingPresenceEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent } from '../types';
+import type { WaAccountTakeoverNoticeEvent, WaGroupEvent, WaIncomingBaseEvent, WaIncomingCallEvent, WaIncomingChatstateEvent, WaIncomingFailureEvent, WaIncomingNodeHandlerRegistration, WaIncomingNotificationEvent, WaIncomingPresenceEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent, WaRegistrationCodeEvent } 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 {
@@ -28,10 +30,13 @@ interface WaIncomingNodeRuntime {
     readonly emitIncomingFailure: (event: WaIncomingFailureEvent) => void;
     readonly emitIncomingErrorStanza: (event: WaIncomingBaseEvent) => void;
     readonly emitIncomingNotification: (event: WaIncomingNotificationEvent) => void;
+    readonly emitRegistrationCode: (event: WaRegistrationCodeEvent) => void;
+    readonly emitAccountTakeoverNotice: (event: WaAccountTakeoverNoticeEvent) => void;
     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>;
@@ -39,10 +44,12 @@ interface WaIncomingNodeRuntime {
 interface WaIncomingNodeCoordinatorOptions {
     readonly logger: Logger;
     readonly runtime: WaIncomingNodeRuntime;
+    readonly offlineResume: WaOfflineResumeCoordinator;
 }
 export declare class WaIncomingNodeCoordinator {
     private readonly logger;
     private readonly runtime;
+    private readonly offlineResume;
     private readonly nodeHandlerRegistry;
     private mediaConnWarmupPromise;
     constructor(options: WaIncomingNodeCoordinatorOptions);

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

@@ -2,15 +2,20 @@ import type { WaAppStateSyncKey } from '../../appstate/types';
 import type { DeviceFanoutResolver } from '../messaging/fanout';
 import type { AppStateSyncKeyProtocol } from '../messaging/key-protocol';
 import type { GroupParticipantsCache } from '../messaging/participants';
-import type { WaGroupEvent, WaSignalMessagePublishInput, WaSendMessageOptions } from '../types';
+import type { WaGroupEvent, WaSendMessageOptions, WaSignalMessagePublishInput } from '../types';
 import type { Logger } from '../../infra/log/types';
 import type { WaEncryptedMessageInput, WaMessagePublishOptions, WaMessagePublishResult, WaSendMessageContent, WaSendReceiptInput } from '../../message/types';
 import type { WaMessageClient } from '../../message/WaMessageClient';
-import type { Proto } from '../..';
+import { type Proto } from '../..';
 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 { WaIdentityStore } from '../../store/contracts/identity.store';
+import type { WaMessageSecretStore } from '../../store/contracts/message-secret.store';
+import type { WaSessionStore } from '../../store/contracts/session.store';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
 import type { BinaryNode } from '../../transport/types';
 interface WaMessageDispatchCoordinatorOptions {
     readonly logger: Logger;
@@ -23,9 +28,18 @@ interface WaMessageDispatchCoordinatorOptions {
     readonly buildMessageContent: (content: WaSendMessageContent) => Promise<Proto.IMessage>;
     readonly senderKeyManager: SenderKeyManager;
     readonly signalProtocol: SignalProtocol;
+    readonly signalStore: WaSignalStore;
+    readonly sessionStore: WaSessionStore;
+    readonly identityStore: WaIdentityStore;
+    readonly deviceListStore: WaDeviceListStore;
+    readonly messageSecretStore: WaMessageSecretStore;
     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;
+    readonly getIcdcHashLength?: () => number;
+    readonly mobileMessageIdFormat?: boolean;
 }
 export declare class WaMessageDispatchCoordinator {
     private readonly logger;
@@ -38,9 +52,21 @@ export declare class WaMessageDispatchCoordinator {
     private readonly buildMessageContent;
     private readonly senderKeyManager;
     private readonly signalProtocol;
+    private readonly signalStore;
+    private readonly sessionStore;
+    private readonly identityStore;
+    private readonly deviceListStore;
+    private readonly messageSecretStore;
     private readonly getCurrentMeJid;
     private readonly getCurrentMeLid;
     private readonly getCurrentSignedIdentity;
+    private readonly resolvePrivacyTokenNode;
+    private readonly onDirectMessageSent;
+    private readonly getIcdcHashLength;
+    private readonly mobileMessageIdFormat;
+    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 +88,7 @@ export declare class WaMessageDispatchCoordinator {
     private generateOutgoingMessageId;
     private tryBuildReportingTokenArtifacts;
     private getEncodedSignedDeviceIdentity;
+    private resolveUserIcdc;
     private requireCurrentMeJid;
 }
 export {};