zapo-js 0.2.0 → 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/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?: {
@@ -33,6 +39,40 @@ export interface WaAuthClientOptions {
     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,19 +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 { 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 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 {
@@ -22,11 +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;
@@ -43,10 +48,10 @@ export declare class WaClient extends EventEmitter {
     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;
@@ -69,10 +74,13 @@ 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;
@@ -86,7 +94,7 @@ 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>;
@@ -96,6 +104,8 @@ export declare class WaClient extends EventEmitter {
     get privacy(): WaPrivacyCoordinator;
     get profile(): WaProfileCoordinator;
     get business(): WaBusinessCoordinator;
+    get email(): WaEmailCoordinator;
+    logout(reason?: WaLogoutReason): Promise<void>;
     sendReceipt(input: WaSendReceiptInput): Promise<void>;
     flushAppStateMutations(): Promise<void>;
     flushWriteBehind(timeoutMs?: number): Promise<WriteBehindDrainResult>;
@@ -106,6 +116,7 @@ export declare class WaClient extends EventEmitter {
     private emitChatEventsFromAppStateSyncResult;
     private handleNctSaltMutation;
     private clearStoredState;
+    private tryDecryptAddon;
     private tryEnterIncomingHandler;
     private leaveIncomingHandler;
     private pauseIncomingEventsAndWaitDrain;

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

@@ -2,10 +2,11 @@ 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';
@@ -39,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;
@@ -77,10 +82,11 @@ interface WaClientDependencies {
     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/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

@@ -1,4 +1,4 @@
-import type { WaEditBusinessProfileInput } from '../../transport/node/builders/business';
+import { type WaEditBusinessProfileInput } from '../../transport/node/builders/business';
 import type { BinaryNode } from '../../transport/types';
 export interface WaBusinessCategory {
     readonly id: string;

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,6 +1,7 @@
 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';
@@ -29,6 +30,8 @@ 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>;
@@ -41,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,16 +2,19 @@ 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 {
@@ -26,12 +29,17 @@ interface WaMessageDispatchCoordinatorOptions {
     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;
@@ -45,12 +53,17 @@ export declare class WaMessageDispatchCoordinator {
     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;

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,35 +1,47 @@
+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>;
@@ -39,7 +51,6 @@ export declare class WaPassiveTasksCoordinator {
     private validateDigestAndRecoverPreKeys;
     private uploadPreKeysIfMissing;
     private rotateSignedPreKeyIfDue;
-    private resolveLocalKeyBundle;
     private resolveLocalKeyBundleFromStore;
     private resolveRotationTimestamp;
     private flushDanglingReceipts;

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

@@ -1,4 +1,4 @@
-import type { WaPrivacyDisallowedListSettingName, WaPrivacySettingName, WaPrivacySettingValueMap } from '../../protocol/privacy';
+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];

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

@@ -1,4 +1,4 @@
-import type { WaProfilePictureType } from '../../transport/node/builders/profile';
+import { type WaProfilePictureType } from '../../transport/node/builders/profile';
 import type { BinaryNode } from '../../transport/types';
 export interface WaProfilePictureResult {
     readonly url?: string;
@@ -29,7 +29,9 @@ export interface WaProfileCoordinator {
     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 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;

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;

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

@@ -8,11 +8,19 @@ type WaTrustedContactTokenRuntime = {
     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 config;
+    private readonly baseConfig;
+    private readonly getConfigOverrides;
     private readonly csTokenGenerator;
     private readonly senderTokenDedup;
     private cachedNctSalt;
@@ -26,7 +34,9 @@ export declare class WaTrustedContactTokenCoordinator {
         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>;

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>;