zapo-js 0.1.0

package/dist/types/appstate/types.d.ts

@@ -0,0 +1,66 @@
+import type { Proto } from '..';
+import type { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES } from '../protocol/constants';
+export type AppStateCollectionName = (typeof WA_APP_STATE_COLLECTIONS)[keyof typeof WA_APP_STATE_COLLECTIONS];
+export type AppStateCollectionState = (typeof WA_APP_STATE_COLLECTION_STATES)[keyof typeof WA_APP_STATE_COLLECTION_STATES];
+export interface WaAppStateSyncKey {
+    readonly keyId: Uint8Array;
+    readonly keyData: Uint8Array;
+    readonly timestamp: number;
+    readonly fingerprint?: Proto.Message.IAppStateSyncKeyFingerprint;
+}
+export interface WaAppStateCollectionVersion {
+    readonly version: number;
+    readonly hash: Uint8Array;
+    readonly indexValueMap: Readonly<Record<string, Uint8Array>>;
+}
+export interface WaAppStateStoreData {
+    readonly keys: readonly WaAppStateSyncKey[];
+    readonly collections: Partial<Record<AppStateCollectionName, WaAppStateCollectionVersion>>;
+}
+export type WaAppStateMutationInput = {
+    readonly collection: AppStateCollectionName;
+    readonly operation: 'set';
+    readonly index: string;
+    readonly value: Proto.ISyncActionValue;
+    readonly version: number;
+    readonly timestamp: number;
+} | {
+    readonly collection: AppStateCollectionName;
+    readonly operation: 'remove';
+    readonly index: string;
+    readonly previousValue: Proto.ISyncActionValue;
+    readonly version: number;
+    readonly timestamp: number;
+};
+export interface WaAppStateMutation {
+    readonly collection: AppStateCollectionName;
+    readonly operation: 'set' | 'remove';
+    readonly source: 'snapshot' | 'patch';
+    readonly index: string;
+    readonly value: Proto.ISyncActionValue | null;
+    readonly version: number;
+    readonly indexMac: Uint8Array;
+    readonly valueMac: Uint8Array;
+    readonly keyId: Uint8Array;
+    readonly timestamp: number;
+}
+export interface WaAppStateCollectionSyncResult {
+    readonly collection: AppStateCollectionName;
+    readonly state: AppStateCollectionState;
+    readonly version?: number;
+    readonly mutations?: readonly WaAppStateMutation[];
+}
+export interface WaAppStateSyncResult {
+    readonly collections: readonly WaAppStateCollectionSyncResult[];
+}
+export interface WaAppStateMissingKeysEvent {
+    readonly keyIds: readonly Uint8Array[];
+    readonly collections: readonly AppStateCollectionName[];
+}
+export interface WaAppStateSyncOptions {
+    readonly collections?: readonly AppStateCollectionName[];
+    readonly pendingMutations?: readonly WaAppStateMutationInput[];
+    readonly downloadExternalBlob?: (collection: AppStateCollectionName, kind: 'snapshot' | 'patch', reference: Proto.IExternalBlobReference) => Promise<Uint8Array>;
+    readonly timeoutMs?: number;
+    readonly onMissingKeys?: (event: WaAppStateMissingKeysEvent) => Promise<void>;
+}

package/dist/types/appstate/utils.d.ts

@@ -0,0 +1,10 @@
+import type { AppStateCollectionName, WaAppStateSyncKey } from './types';
+import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
+import type { Proto } from '..';
+export declare function keyIdToHex(keyId: Uint8Array): string;
+export declare function parseCollectionName(value: string | undefined): AppStateCollectionName | null;
+export declare function keyDeviceId(keyId: Uint8Array): number | null;
+export declare function keyEpoch(keyId: Uint8Array): number;
+export declare function pickActiveSyncKey(keys: Iterable<WaAppStateSyncKey>): WaAppStateSyncKey | null;
+export declare function toNetworkOrder64(value: number): Uint8Array;
+export declare function downloadExternalBlobReference(mediaTransfer: WaMediaTransferClient, reference: Proto.IExternalBlobReference): Promise<Uint8Array>;

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

@@ -0,0 +1,61 @@
+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 { WaSignalStore } from '../store/contracts/signal.store';
+import type { BinaryNode } from '../transport/types';
+interface WaAuthClientCallbacks {
+    readonly onQr?: (qr: string, ttlMs: number) => void;
+    readonly onPairingCode?: (code: string) => void;
+    readonly onPairingRefresh?: (forceManual: boolean) => void;
+    readonly onPaired?: (credentials: WaAuthCredentials) => void;
+    readonly onError?: (error: Error) => void;
+}
+interface WaAuthClientDependencies {
+    readonly logger: Logger;
+    readonly authStore: WaAuthStore;
+    readonly signalStore: WaSignalStore;
+    readonly socket: {
+        readonly sendNode: (node: BinaryNode) => Promise<void>;
+        readonly query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    };
+    readonly callbacks?: WaAuthClientCallbacks;
+}
+export declare class WaAuthClient {
+    private readonly options;
+    private readonly logger;
+    private readonly callbacks;
+    private readonly authStore;
+    private readonly signalStore;
+    private readonly qrFlow;
+    private readonly pairingFlow;
+    private credentials;
+    constructor(options: WaAuthClientOptions, deps: WaAuthClientDependencies);
+    getState(connected?: boolean): {
+        connected: boolean;
+        registered: boolean;
+        hasQr: boolean;
+        hasPairingCode: boolean;
+    };
+    getCurrentCredentials(): WaAuthCredentials | null;
+    loadOrCreateCredentials(): Promise<WaAuthCredentials>;
+    buildCommsConfig(socketOptions: WaAuthSocketOptions): import("../transport/types").WaCommsConfig;
+    clearTransientState(): Promise<void>;
+    clearStoredCredentials(): Promise<void>;
+    persistServerStaticKey(serverStaticKey: Uint8Array): Promise<void>;
+    persistServerHasPreKeys(serverHasPreKeys: boolean): Promise<void>;
+    persistRoutingInfo(routingInfo: Uint8Array): Promise<void>;
+    clearRoutingInfo(): Promise<WaAuthCredentials>;
+    persistMeLid(meLid: string): Promise<void>;
+    persistSuccessAttributes(attributes: WaSuccessPersistAttributes): Promise<void>;
+    requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean): Promise<string>;
+    fetchPairingCountryCodeIso(): Promise<string>;
+    handleIncomingIqSet(node: BinaryNode): Promise<boolean>;
+    handleLinkCodeNotification(node: BinaryNode): Promise<boolean>;
+    handleCompanionRegRefreshNotification(node: BinaryNode): Promise<boolean>;
+    private patchCredentials;
+    private runHandled;
+    private updateCredentials;
+    private requireCredentials;
+    private handleError;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import type { WaAuthClientOptions, WaAuthCredentials, WaAuthSocketOptions } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { WaAuthStore } from '../../store/contracts/auth.store';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { WaCommsConfig } from '../../transport/types';
+interface WaAuthCredentialsFlowArgs {
+    readonly logger: Logger;
+    readonly authStore: WaAuthStore;
+    readonly signalStore: WaSignalStore;
+}
+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'>): WaCommsConfig;
+export {};

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

@@ -0,0 +1,6 @@
+export * from './types';
+export { getLoginIdentity } from '../protocol/jid';
+export { WaAuthClient } from './WaAuthClient';
+export { completeCompanionFinish, createCompanionHello } from './pairing/WaPairingCodeCrypto';
+export { WaAuthSqliteStore } from '../store/providers/sqlite/auth.store';
+export type { WaAuthStore } from '../store/contracts/auth.store';

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

@@ -0,0 +1,17 @@
+import type { SignalKeyPair } from '../../crypto/curves/types';
+export declare function createCompanionHello(): Promise<{
+    readonly pairingCode: string;
+    readonly companionEphemeralKeyPair: SignalKeyPair;
+    readonly wrappedCompanionEphemeralPub: Uint8Array;
+}>;
+export declare function completeCompanionFinish(args: {
+    readonly pairingCode: string;
+    readonly wrappedPrimaryEphemeralPub: Uint8Array;
+    readonly primaryIdentityPub: Uint8Array;
+    readonly companionEphemeralPrivKey: Uint8Array;
+    readonly registrationIdentityKeyPair: SignalKeyPair;
+}): Promise<{
+    readonly wrappedKeyBundle: Uint8Array;
+    readonly companionIdentityPublic: Uint8Array;
+    readonly advSecret: Uint8Array;
+}>;

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

@@ -0,0 +1,48 @@
+import type { WaAuthCredentials } from '../types';
+import type { Logger } from '../../infra/log/types';
+import type { BinaryNode } from '../../transport/types';
+interface WaPairingFlowOptions {
+    readonly logger: Logger;
+    readonly auth: {
+        readonly getCredentials: () => WaAuthCredentials | null;
+        readonly updateCredentials: (credentials: WaAuthCredentials) => Promise<void>;
+    };
+    readonly socket: {
+        readonly sendNode: (node: BinaryNode) => Promise<void>;
+        readonly query: (node: BinaryNode, timeoutMs: number) => Promise<BinaryNode>;
+    };
+    readonly qrFlow: {
+        readonly setRefs: (refs: readonly string[]) => void;
+        readonly clear: () => void;
+        readonly refreshCurrentQr: () => boolean;
+    };
+    readonly device: {
+        readonly browser: string;
+        readonly osDisplayName: string;
+        readonly platform: string;
+    };
+    readonly callbacks: {
+        readonly emitPairingCode: (code: string) => void;
+        readonly emitPairingRefresh: (forceManual: boolean) => void;
+        readonly emitPaired: (credentials: WaAuthCredentials) => void;
+    };
+}
+export declare class WaPairingFlow {
+    private readonly opts;
+    private pairingSession;
+    constructor(options: WaPairingFlowOptions);
+    hasPairingSession(): boolean;
+    clearSession(): void;
+    requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean): Promise<string>;
+    fetchPairingCountryCodeIso(): Promise<string>;
+    handleIncomingIqSet(node: BinaryNode): Promise<boolean>;
+    handleLinkCodeNotification(node: BinaryNode): Promise<boolean>;
+    handleCompanionRegRefreshNotification(node: BinaryNode): Promise<boolean>;
+    private handlePairDevice;
+    private handlePairSuccess;
+    private buildPairSuccessResponseIdentity;
+    private handlePrimaryHello;
+    private rotateAdvSecret;
+    private requireCredentials;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import type { WaAuthCredentials } from '../types';
+import type { Logger } from '../../infra/log/types';
+export declare class WaQrFlow {
+    private readonly logger;
+    private readonly getCredentials;
+    private readonly getDevicePlatform;
+    private readonly emitQr;
+    private qrRefs;
+    private currentRef;
+    private currentQrTimer;
+    constructor(args: {
+        readonly logger: Logger;
+        readonly getCredentials: () => WaAuthCredentials | null;
+        readonly getDevicePlatform: () => string;
+        readonly emitQr: (qr: string, ttlMs: number) => void;
+    });
+    hasQr(): boolean;
+    clear(): void;
+    refreshCurrentQr(): boolean;
+    setRefs(refs: readonly string[]): void;
+    private rotateRef;
+    private buildQr;
+}

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

@@ -0,0 +1,2 @@
+export declare const CROCKFORD_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTVWXYZ";
+export declare const PBKDF2_ITERATIONS: number;

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

@@ -0,0 +1,48 @@
+import type { SignalKeyPair } from '../crypto/curves/types';
+import type { Proto } from '..';
+import type { RegistrationInfo, SignedPreKeyRecord } from '../signal/types';
+export interface WaAuthCredentials {
+    readonly noiseKeyPair: SignalKeyPair;
+    readonly registrationInfo: RegistrationInfo;
+    readonly signedPreKey: SignedPreKeyRecord;
+    readonly advSecretKey: Uint8Array;
+    readonly signedIdentity?: Proto.IADVSignedDeviceIdentity;
+    readonly meJid?: string;
+    readonly meLid?: string;
+    readonly meDisplayName?: string;
+    readonly companionEncStatic?: Uint8Array;
+    readonly platform?: string;
+    readonly serverStaticKey?: Uint8Array;
+    readonly serverHasPreKeys?: boolean;
+    readonly routingInfo?: Uint8Array;
+    readonly lastSuccessTs?: number;
+    readonly propsVersion?: number;
+    readonly abPropsVersion?: number;
+    readonly connectionLocation?: string;
+    readonly accountCreationTs?: number;
+}
+export interface WaAuthSocketOptions {
+    readonly url?: string;
+    readonly urls?: readonly string[];
+    readonly protocols?: readonly string[];
+    readonly connectTimeoutMs?: number;
+    readonly reconnectIntervalMs?: number;
+    readonly timeoutIntervalMs?: number;
+    readonly maxReconnectAttempts?: number;
+}
+export interface WaAuthClientOptions {
+    readonly deviceBrowser?: string;
+    readonly devicePlatform?: string;
+    readonly deviceOsDisplayName?: string;
+    readonly requireFullSync?: boolean;
+}
+export interface WaSuccessPersistAttributes {
+    readonly meLid?: string;
+    readonly meDisplayName?: string;
+    readonly companionEncStatic?: Uint8Array;
+    readonly lastSuccessTs?: number;
+    readonly propsVersion?: number;
+    readonly abPropsVersion?: number;
+    readonly connectionLocation?: string;
+    readonly accountCreationTs?: number;
+}

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

@@ -0,0 +1,97 @@
+import { EventEmitter } from 'node:events';
+import type { WaAppStateStoreData, WaAppStateSyncResult } from '../appstate/types';
+import type { WaAppStateSyncOptions } from '../appstate/types';
+import type { WaAppStateSyncClient } from '../appstate/WaAppStateSyncClient';
+import type { WaAuthCredentials } from '../auth/types';
+import type { WaGroupCoordinator } from './coordinators/WaGroupCoordinator';
+import type { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator';
+import type { WaClientEventMap, WaClientOptions, WaSendMessageOptions, WaIncomingNodeHandlerRegistration } 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 { BinaryNode } from '../transport/types';
+export declare class WaClient extends EventEmitter {
+    private readonly options;
+    private readonly logger;
+    private readonly appStateStore;
+    private readonly contactStore;
+    private readonly messageStore;
+    private readonly participantsStore;
+    private readonly deviceListStore;
+    private readonly retryStore;
+    private readonly signalStore;
+    private readonly senderKeyStore;
+    private readonly threadStore;
+    private readonly authClient;
+    private readonly nodeOrchestrator;
+    private readonly keepAlive;
+    private readonly nodeTransport;
+    readonly appStateSync: WaAppStateSyncClient;
+    private readonly incomingNode;
+    private readonly passiveTasks;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly messageDispatch: WaMessageDispatchCoordinator;
+    readonly messageClient: WaMessageClient;
+    readonly groupCoordinator: WaGroupCoordinator;
+    private clockSkewMs;
+    private mediaConnCache;
+    private comms;
+    private pairingReconnectPromise;
+    private connectPromise;
+    private readonly danglingReceipts;
+    private readonly appStateKeyShareWaiters;
+    private appStateKeyShareVersion;
+    private appStateBootstrapKeyShareWaitDone;
+    constructor(options: WaClientOptions, logger?: Logger);
+    on<K extends keyof WaClientEventMap>(event: K, listener: WaClientEventMap[K]): this;
+    once<K extends keyof WaClientEventMap>(event: K, listener: WaClientEventMap[K]): this;
+    off<K extends keyof WaClientEventMap>(event: K, listener: WaClientEventMap[K]): this;
+    emit<K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>): boolean;
+    getState(): {
+        connected: boolean;
+        registered: boolean;
+        hasQr: boolean;
+        hasPairingCode: boolean;
+    };
+    getCredentials(): WaAuthCredentials | null;
+    getClockSkewMs(): number | null;
+    sendNode(node: BinaryNode): Promise<void>;
+    query(node: BinaryNode, timeoutMs?: number): Promise<BinaryNode>;
+    registerIncomingHandler(registration: WaIncomingNodeHandlerRegistration): () => void;
+    unregisterIncomingHandler(registration: WaIncomingNodeHandlerRegistration): boolean;
+    private bindNodeTransportEvents;
+    private handleIncomingMessageEvent;
+    private handleIncomingAppStateSyncKeyShare;
+    private handleIncomingAppStateSyncKeyRequest;
+    private extractAppStateSyncKeyRequestIds;
+    private isOwnAccountDeviceJid;
+    private handleHistorySyncNotification;
+    private queryWithContext;
+    private handleIncomingFrame;
+    connect(): Promise<void>;
+    private connectInternal;
+    private scheduleReconnectAfterPairing;
+    private reconnectAsRegisteredAfterPairing;
+    private reconnectAsRegisteredAfterPairingInternal;
+    disconnect(): Promise<void>;
+    requestPairingCode(phoneNumber: string, shouldShowPushNotification?: boolean): Promise<string>;
+    fetchPairingCountryCodeIso(): Promise<string>;
+    sendMessage(to: string, content: WaSendMessageContent, options?: WaSendMessageOptions): Promise<WaMessagePublishResult>;
+    syncSignalSession(jid: string, reasonIdentity?: boolean): Promise<void>;
+    sendReceipt(input: WaSendReceiptInput): Promise<void>;
+    exportAppState(): Promise<WaAppStateStoreData>;
+    syncAppState(options?: WaAppStateSyncOptions): Promise<WaAppStateSyncResult>;
+    private executeAppStateSync;
+    private getBlockedAppStateCollections;
+    private waitForAppStateKeyShare;
+    private notifyAppStateKeyShareWaiters;
+    private emitChatEventsFromAppStateSyncResult;
+    private startCommsWithCredentials;
+    private shouldQueueDanglingReceipt;
+    private enqueueDanglingReceipt;
+    private clearStoredState;
+    private handleError;
+    private clearCommsBinding;
+    private updateClockSkewFromSuccess;
+}

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

@@ -0,0 +1,83 @@
+import { WaAppStateSyncClient } from '../appstate/WaAppStateSyncClient';
+import { WaAuthClient } from '../auth/WaAuthClient';
+import { type WaGroupCoordinator } from './coordinators/WaGroupCoordinator';
+import { WaIncomingNodeCoordinator } from './coordinators/WaIncomingNodeCoordinator';
+import { WaMessageDispatchCoordinator } from './coordinators/WaMessageDispatchCoordinator';
+import { WaPassiveTasksCoordinator } from './coordinators/WaPassiveTasksCoordinator';
+import { WaRetryCoordinator } from './coordinators/WaRetryCoordinator';
+import { type WaStreamControlHandler } from './coordinators/WaStreamControlCoordinator';
+import { buildMediaMessageContent } from './messages';
+import type { WaClientEventMap, WaClientOptions, WaIncomingMessageEvent } from './types';
+import type { Logger } from '../infra/log/types';
+import type { WaMediaConn } from '../media/types';
+import { WaMediaTransferClient } from '../media/WaMediaTransferClient';
+import { WaMessageClient } from '../message/WaMessageClient';
+import { SignalDeviceSyncApi } from '../signal/api/SignalDeviceSyncApi';
+import { SignalDigestSyncApi } from '../signal/api/SignalDigestSyncApi';
+import { SignalIdentitySyncApi } from '../signal/api/SignalIdentitySyncApi';
+import { SignalMissingPreKeysSyncApi } from '../signal/api/SignalMissingPreKeysSyncApi';
+import { SignalRotateKeyApi } from '../signal/api/SignalRotateKeyApi';
+import { SignalSessionSyncApi } from '../signal/api/SignalSessionSyncApi';
+import { SenderKeyManager } from '../signal/group/SenderKeyManager';
+import { SignalProtocol } from '../signal/session/SignalProtocol';
+import { WaKeepAlive } from '../transport/keepalive/WaKeepAlive';
+import { WaNodeOrchestrator } from '../transport/node/WaNodeOrchestrator';
+import { WaNodeTransport } from '../transport/node/WaNodeTransport';
+import type { BinaryNode } from '../transport/types';
+import type { WaComms } from '../transport/WaComms';
+type WaMediaMessageBuildOptions = Parameters<typeof buildMediaMessageContent>[0];
+interface WaClientBase {
+    readonly options: Readonly<WaClientOptions>;
+    readonly logger: Logger;
+    readonly sessionStore: ReturnType<WaClientOptions['store']['session']>;
+}
+interface WaClientDependencies {
+    readonly nodeTransport: WaNodeTransport;
+    readonly nodeOrchestrator: WaNodeOrchestrator;
+    readonly keepAlive: WaKeepAlive;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly mediaMessageBuildOptions: WaMediaMessageBuildOptions;
+    readonly messageClient: WaMessageClient;
+    readonly senderKeyManager: SenderKeyManager;
+    readonly signalProtocol: SignalProtocol;
+    readonly signalDigestSync: SignalDigestSyncApi;
+    readonly signalDeviceSync: SignalDeviceSyncApi;
+    readonly signalIdentitySync: SignalIdentitySyncApi;
+    readonly signalMissingPreKeysSync: SignalMissingPreKeysSyncApi;
+    readonly signalRotateKey: SignalRotateKeyApi;
+    readonly signalSessionSync: SignalSessionSyncApi;
+    readonly authClient: WaAuthClient;
+    readonly messageDispatch: WaMessageDispatchCoordinator;
+    readonly retryCoordinator: WaRetryCoordinator;
+    readonly appStateSync: WaAppStateSyncClient;
+    readonly streamControl: WaStreamControlHandler;
+    readonly incomingNode: WaIncomingNodeCoordinator;
+    readonly passiveTasks: WaPassiveTasksCoordinator;
+    readonly groupCoordinator: WaGroupCoordinator;
+}
+export interface WaClientDependencyHost {
+    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 syncAppState: () => Promise<void>;
+    readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
+    readonly handleIncomingMessageEvent: (event: WaIncomingMessageEvent) => Promise<void>;
+    readonly handleError: (error: Error) => void;
+    readonly scheduleReconnectAfterPairing: () => void;
+    readonly updateClockSkewFromSuccess: (serverUnixSeconds: number) => void;
+    readonly getComms: () => WaComms | null;
+    readonly getMediaConnCache: () => WaMediaConn | null;
+    readonly setMediaConnCache: (mediaConn: WaMediaConn | null) => void;
+    readonly disconnect: () => Promise<void>;
+    readonly clearStoredState: () => Promise<void>;
+    readonly connect: () => Promise<void>;
+    readonly shouldQueueDanglingReceipt: (node: BinaryNode, error: Error) => boolean;
+    readonly enqueueDanglingReceipt: (node: BinaryNode) => void;
+    readonly takeDanglingReceipts: () => BinaryNode[];
+}
+export declare function resolveWaClientBase(options: WaClientOptions, logger: Logger): WaClientBase;
+export declare function buildWaClientDependencies(input: {
+    readonly base: WaClientBase;
+    readonly host: WaClientDependencyHost;
+}): WaClientDependencies;
+export {};

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

@@ -0,0 +1,48 @@
+import { type WaGroupSetting } from '../../protocol/group';
+import type { BinaryNode } from '../../transport/types';
+export interface WaGroupParticipant {
+    readonly jid: string;
+    readonly type: string;
+    readonly isAdmin: boolean;
+    readonly isSuperAdmin: boolean;
+}
+export interface WaGroupMetadata {
+    readonly jid: string;
+    readonly subject: string;
+    readonly subjectOwner?: string;
+    readonly subjectTime?: number;
+    readonly owner?: string;
+    readonly creation?: number;
+    readonly desc?: string;
+    readonly descId?: string;
+    readonly descOwner?: string;
+    readonly restrict: boolean;
+    readonly announce: boolean;
+    readonly ephemeral?: number;
+    readonly size?: number;
+    readonly participants: readonly WaGroupParticipant[];
+}
+export interface WaGroupCreateOptions {
+    readonly description?: string;
+}
+interface WaGroupCoordinatorOptions {
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+}
+export interface WaGroupCoordinator {
+    readonly queryGroupMetadata: (groupJid: string) => Promise<WaGroupMetadata>;
+    readonly queryAllGroups: () => Promise<readonly WaGroupMetadata[]>;
+    readonly queryGroupInviteInfo: (code: string) => Promise<BinaryNode>;
+    readonly createGroup: (subject: string, participants: readonly string[], options?: WaGroupCreateOptions) => Promise<BinaryNode>;
+    readonly setSubject: (groupJid: string, subject: string) => Promise<void>;
+    readonly setDescription: (groupJid: string, description: string | null, prevDescId?: string) => Promise<void>;
+    readonly setSetting: (groupJid: string, setting: WaGroupSetting, enabled: boolean) => Promise<void>;
+    readonly addParticipants: (groupJid: string, participants: readonly string[]) => Promise<BinaryNode>;
+    readonly removeParticipants: (groupJid: string, participants: readonly string[]) => Promise<BinaryNode>;
+    readonly promoteParticipants: (groupJid: string, participants: readonly string[]) => Promise<BinaryNode>;
+    readonly demoteParticipants: (groupJid: string, participants: readonly string[]) => Promise<BinaryNode>;
+    readonly leaveGroup: (groupJids: readonly string[]) => Promise<BinaryNode>;
+    readonly revokeInvite: (groupJid: string) => Promise<BinaryNode>;
+    readonly joinGroupViaInvite: (code: string) => Promise<BinaryNode>;
+}
+export declare function createGroupCoordinator(options: WaGroupCoordinatorOptions): WaGroupCoordinator;
+export {};

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

@@ -0,0 +1,60 @@
+import type { WaSuccessPersistAttributes } from '../../auth/types';
+import type { WaDirtyBit } from '../dirty';
+import type { WaIncomingBaseEvent, WaIncomingCallEvent, WaIncomingChatstateEvent, WaIncomingFailureEvent, WaGroupEvent, WaIncomingNodeHandlerRegistration, WaIncomingNotificationEvent, WaIncomingPresenceEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent } from '../types';
+import type { Logger } from '../../infra/log/types';
+import { type WaStreamControlNodeResult } from '../../transport/stream/parse';
+import type { BinaryNode } from '../../transport/types';
+interface WaIncomingNodeRuntime {
+    readonly handleStreamControlResult: (result: WaStreamControlNodeResult) => Promise<void>;
+    readonly persistSuccessAttributes: (attributes: WaSuccessPersistAttributes) => Promise<void>;
+    readonly emitSuccessNode: (node: BinaryNode) => void;
+    readonly updateClockSkewFromSuccess: (serverUnixSeconds: number) => void;
+    readonly shouldWarmupMediaConn: () => boolean;
+    readonly warmupMediaConn: () => Promise<void>;
+    readonly persistRoutingInfo: (routingInfo: Uint8Array) => Promise<void>;
+    readonly tryResolvePendingNode: (node: BinaryNode) => boolean;
+    readonly handleGenericIncomingNode: (node: BinaryNode) => Promise<boolean>;
+    readonly handleIncomingIqSetNode: (node: BinaryNode) => Promise<boolean>;
+    readonly handleLinkCodeNotificationNode: (node: BinaryNode) => Promise<boolean>;
+    readonly handleCompanionRegRefreshNotificationNode: (node: BinaryNode) => Promise<boolean>;
+    readonly handleIncomingMessageNode: (node: BinaryNode) => Promise<boolean>;
+    readonly sendNode: (node: BinaryNode) => Promise<void>;
+    readonly handleIncomingRetryReceipt: (node: BinaryNode) => Promise<void>;
+    readonly trackOutboundReceipt: (node: BinaryNode) => Promise<void>;
+    readonly emitIncomingReceipt: (event: WaIncomingReceiptEvent) => void;
+    readonly emitIncomingPresence: (event: WaIncomingPresenceEvent) => void;
+    readonly emitIncomingChatstate: (event: WaIncomingChatstateEvent) => void;
+    readonly emitIncomingCall: (event: WaIncomingCallEvent) => void;
+    readonly emitIncomingFailure: (event: WaIncomingFailureEvent) => void;
+    readonly emitIncomingErrorStanza: (event: WaIncomingBaseEvent) => void;
+    readonly emitIncomingNotification: (event: WaIncomingNotificationEvent) => void;
+    readonly emitGroupEvent: (event: WaGroupEvent) => void;
+    readonly emitUnhandledIncomingNode: (event: WaIncomingUnhandledStanzaEvent) => void;
+    readonly syncAppState: () => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    readonly clearStoredCredentials: () => Promise<void>;
+    readonly parseDirtyBits: (nodes: readonly BinaryNode[]) => readonly WaDirtyBit[];
+    readonly handleDirtyBits: (dirtyBits: readonly WaDirtyBit[]) => Promise<void>;
+}
+interface WaIncomingNodeCoordinatorOptions {
+    readonly logger: Logger;
+    readonly runtime: WaIncomingNodeRuntime;
+}
+export declare class WaIncomingNodeCoordinator {
+    private readonly logger;
+    private readonly runtime;
+    private readonly nodeHandlerRegistry;
+    private mediaConnWarmupPromise;
+    constructor(options: WaIncomingNodeCoordinatorOptions);
+    handleIncomingNode(node: BinaryNode): Promise<void>;
+    registerIncomingHandler(registration: WaIncomingNodeHandlerRegistration): () => void;
+    unregisterIncomingHandler(registration: WaIncomingNodeHandlerRegistration): boolean;
+    private dispatchIncomingNode;
+    private isRetryReceiptType;
+    private getHandlersForNode;
+    private registerDefaultIncomingHandlers;
+    private handleSuccessNode;
+    private scheduleMediaConnWarmup;
+    private handleInfoBulletinNode;
+}
+export {};