zapo-js 0.1.0

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

@@ -0,0 +1,90 @@
+import type { WaAppStateSyncKey } from '../../appstate/types';
+import type { WaGroupEvent, WaSignalMessagePublishInput, WaSendMessageOptions } 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 { SignalDeviceSyncApi } from '../../signal/api/SignalDeviceSyncApi';
+import type { SignalIdentitySyncApi } from '../../signal/api/SignalIdentitySyncApi';
+import type { SignalSessionSyncApi } from '../../signal/api/SignalSessionSyncApi';
+import type { SenderKeyManager } from '../../signal/group/SenderKeyManager';
+import type { SignalProtocol } from '../../signal/session/SignalProtocol';
+import type { WaParticipantsStore } from '../../store/contracts/participants.store';
+import type { WaRetryStore } from '../../store/contracts/retry.store';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
+import type { BinaryNode } from '../../transport/types';
+interface WaMessageDispatchCoordinatorOptions {
+    readonly logger: Logger;
+    readonly messageClient: WaMessageClient;
+    readonly retryStore: WaRetryStore;
+    readonly participantsStore: WaParticipantsStore;
+    readonly buildMessageContent: (content: WaSendMessageContent) => Promise<Proto.IMessage>;
+    readonly queryGroupParticipantJids: (groupJid: string) => Promise<readonly string[]>;
+    readonly senderKeyManager: SenderKeyManager;
+    readonly signalProtocol: SignalProtocol;
+    readonly signalStore: WaSignalStore;
+    readonly signalDeviceSync: SignalDeviceSyncApi;
+    readonly signalIdentitySync: SignalIdentitySyncApi;
+    readonly signalSessionSync: SignalSessionSyncApi;
+    readonly getCurrentMeJid: () => string | null | undefined;
+    readonly getCurrentMeLid: () => string | null | undefined;
+    readonly getCurrentSignedIdentity: () => Proto.IADVSignedDeviceIdentity | null | undefined;
+}
+export declare class WaMessageDispatchCoordinator {
+    private readonly logger;
+    private readonly messageClient;
+    private readonly retryStore;
+    private readonly participantsStore;
+    private readonly retryTtlMs;
+    private readonly buildMessageContent;
+    private readonly queryGroupParticipantJids;
+    private readonly senderKeyManager;
+    private readonly signalProtocol;
+    private readonly signalStore;
+    private readonly signalDeviceSync;
+    private readonly signalIdentitySync;
+    private readonly signalSessionSync;
+    private readonly getCurrentMeJid;
+    private readonly getCurrentMeLid;
+    private readonly getCurrentSignedIdentity;
+    constructor(options: WaMessageDispatchCoordinatorOptions);
+    publishMessageNode(node: BinaryNode, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
+    publishEncryptedMessage(input: WaEncryptedMessageInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
+    publishSignalMessage(input: WaSignalMessagePublishInput, options?: WaMessagePublishOptions): Promise<WaMessagePublishResult>;
+    sendMessage(to: string, content: WaSendMessageContent, options?: WaSendMessageOptions): Promise<WaMessagePublishResult>;
+    syncSignalSession(jid: string, reasonIdentity?: boolean): Promise<void>;
+    sendReceipt(input: WaSendReceiptInput): Promise<void>;
+    requestAppStateSyncKeys(keyIds: readonly Uint8Array[]): Promise<readonly string[]>;
+    sendAppStateSyncKeyShare(toDeviceJid: string, keys: readonly WaAppStateSyncKey[], missingKeyIds?: readonly Uint8Array[]): Promise<void>;
+    mutateParticipantsCacheFromGroupEvent(event: WaGroupEvent): Promise<void>;
+    private publishProtocolMessageToDevice;
+    private resolveOwnPeerDeviceJids;
+    private normalizeKeyIds;
+    private publishWithRetryTracking;
+    private createRetryOutboundRecord;
+    private safeUpsertRetryOutboundRecord;
+    private shouldUseGroupDirectPath;
+    private publishGroupDirectMessage;
+    private publishGroupSenderKeyMessage;
+    private resolveGroupParticipantUsers;
+    private resolveGroupJidForParticipantCacheEvent;
+    private extractParticipantUsersFromGroupEvent;
+    private mergeParticipantUsersIntoCache;
+    private removeParticipantUsersFromCache;
+    private replaceParticipantUsersInCache;
+    private areParticipantListsEqual;
+    private refreshGroupParticipantUsers;
+    private sanitizeParticipantUsers;
+    private resolveGroupAddressingMode;
+    private resolveSenderForAddressingMode;
+    private encryptGroupDistributionParticipants;
+    private resolveGroupParticipantDeviceJids;
+    private publishDirectSignalMessageWithFanout;
+    private ensureSignalSessionsBatch;
+    private resolveDirectFanoutDeviceJids;
+    private resolveSelfDeviceJidForRecipient;
+    private getEncodedSignedDeviceIdentity;
+    private ensureSignalSession;
+    private requireCurrentMeJid;
+}
+export {};

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

@@ -0,0 +1,43 @@
+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 { 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 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;
+};
+export declare class WaPassiveTasksCoordinator {
+    private readonly logger;
+    private readonly signalStore;
+    private readonly signalDigestSync;
+    private readonly signalRotateKey;
+    private readonly signedPreKeyRotationIntervalMs;
+    private readonly signedPreKeyServerErrorBackoffMs;
+    private readonly runtime;
+    private passiveTasksPromise;
+    constructor(options: {
+        readonly logger: Logger;
+        readonly signalStore: WaSignalStore;
+        readonly signalDigestSync: SignalDigestSyncApi;
+        readonly signalRotateKey: SignalRotateKeyApi;
+        readonly signedPreKeyRotationIntervalMs?: number;
+        readonly signedPreKeyServerErrorBackoffMs?: number;
+        readonly runtime: WaPassiveTasksRuntime;
+    });
+    startPassiveTasksAfterConnect(): void;
+    resetInFlightState(): void;
+    private runPassiveTasksAfterConnect;
+    private validateDigestAndRecoverPreKeys;
+    private uploadPreKeysIfMissing;
+    private rotateSignedPreKeyIfDue;
+    private resolveRotationTimestamp;
+    private flushDanglingReceipts;
+}
+export {};

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

@@ -0,0 +1,61 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaMessageClient } from '../../message/WaMessageClient';
+import { type Proto } from '../..';
+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 { WaRetryStore } from '../../store/contracts/retry.store';
+import type { WaSenderKeyStore } from '../../store/contracts/sender-key.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 senderKeyStore: WaSenderKeyStore;
+    readonly signalProtocol: SignalProtocol;
+    readonly signalDeviceSync: SignalDeviceSyncApi;
+    readonly signalMissingPreKeysSync: SignalMissingPreKeysSyncApi;
+    readonly messageClient: WaMessageClient;
+    readonly sendNode: (node: BinaryNode) => Promise<void>;
+    readonly getCurrentMeJid: () => string | null | undefined;
+    readonly getCurrentMeLid: () => string | null | undefined;
+    readonly getCurrentSignedIdentity: () => Proto.IADVSignedDeviceIdentity | null | undefined;
+}
+export declare class WaRetryCoordinator {
+    private readonly logger;
+    private readonly retryStore;
+    private readonly retryTtlMs;
+    private readonly signalStore;
+    private readonly senderKeyStore;
+    private readonly signalProtocol;
+    private readonly signalDeviceSync;
+    private readonly signalMissingPreKeysSync;
+    private readonly retryReplayService;
+    private readonly sendNode;
+    private readonly getCurrentMeJid;
+    private readonly getCurrentMeLid;
+    private readonly getCurrentSignedIdentity;
+    private readonly retryProcessingByMessageId;
+    constructor(options: WaRetryCoordinatorOptions);
+    onDecryptFailure(context: WaRetryDecryptFailureContext, error: unknown): Promise<boolean>;
+    handleIncomingRetryReceipt(receiptNode: BinaryNode): Promise<void>;
+    private isRetryReceiptNode;
+    private prepareDecryptFailureRetry;
+    private sendDecryptFailureRetryReceipt;
+    private handleParsedRetryRequest;
+    private processRetryRequest;
+    private prepareRetryResend;
+    trackOutboundReceipt(receiptNode: BinaryNode): Promise<void>;
+    private runRetryTaskSerialized;
+    private buildRetryKeysSection;
+    private updateLocalSessionFromRetryRequest;
+    private markRetryRequesterSenderKeyAsStale;
+    private fetchMissingPreKeysSession;
+    private authorizeRetryRequest;
+    private isRequesterAuthorizedDevice;
+    private mapOutboundStateFromReceiptType;
+    private sendRetryAckSafe;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import type { Logger } from '../../infra/log/types';
+import type { WaStreamControlNodeResult } from '../../transport/stream/parse';
+import type { WaComms } from '../../transport/WaComms';
+interface WaStreamControlCoordinatorOptions {
+    readonly logger: Logger;
+    readonly getComms: () => WaComms | null;
+    readonly clearPendingQueries: (error: Error) => void;
+    readonly clearMediaConnCache: () => void;
+    readonly disconnect: () => Promise<void>;
+    readonly clearStoredCredentials: () => Promise<void>;
+    readonly connect: () => Promise<void>;
+}
+export interface WaStreamControlHandler {
+    readonly handleStreamControlResult: (result: WaStreamControlNodeResult) => Promise<void>;
+}
+export declare function createStreamControlHandler(options: WaStreamControlCoordinatorOptions): WaStreamControlHandler;
+export {};

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

@@ -0,0 +1,17 @@
+import type { WaAuthCredentials } from '../auth/types';
+import type { Logger } from '../infra/log/types';
+import type { BinaryNode } from '../transport/types';
+export interface WaDirtyBit {
+    readonly type: string;
+    readonly timestamp: number;
+    readonly protocols: readonly string[];
+}
+interface WaDirtySyncRuntime {
+    readonly logger: Logger;
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly getCurrentCredentials: () => WaAuthCredentials | null;
+    readonly syncAppState: () => Promise<void>;
+}
+export declare function parseDirtyBits(nodes: readonly BinaryNode[], logger: Logger): readonly WaDirtyBit[];
+export declare function handleDirtyBits(runtime: WaDirtySyncRuntime, dirtyBits: readonly WaDirtyBit[]): Promise<void>;
+export {};

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

@@ -0,0 +1,3 @@
+import type { WaAppStateMutation } from '../../appstate/types';
+import type { WaChatEvent } from '../types';
+export declare function parseChatEventFromAppStateMutation(mutation: WaAppStateMutation): WaChatEvent | null;

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

@@ -0,0 +1,7 @@
+import type { WaGroupEvent, WaIncomingUnhandledStanzaEvent } from '../types';
+import type { BinaryNode } from '../../transport/types';
+export interface WaParseGroupNotificationResult {
+    readonly events: readonly WaGroupEvent[];
+    readonly unhandled: readonly WaIncomingUnhandledStanzaEvent[];
+}
+export declare function parseGroupNotificationEvents(notificationNode: BinaryNode): WaParseGroupNotificationResult;

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

@@ -0,0 +1,17 @@
+import type { WaClientEventMap } from './types';
+import type { Logger } from '../infra/log/types';
+import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
+import { type Proto } from '..';
+import type { WaContactStore } from '../store/contracts/contact.store';
+import type { WaMessageStore } from '../store/contracts/message.store';
+import type { WaThreadStore } from '../store/contracts/thread.store';
+interface WaHistorySyncDeps {
+    readonly logger: Logger;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly contactStore: WaContactStore;
+    readonly messageStore: WaMessageStore;
+    readonly threadStore: WaThreadStore;
+    readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
+}
+export declare function processHistorySyncNotification(deps: WaHistorySyncDeps, notification: Proto.Message.IHistorySyncNotification): Promise<void>;
+export {};

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

@@ -0,0 +1,35 @@
+import type { WaIncomingBaseEvent, WaIncomingFailureEvent, WaIncomingNotificationEvent, WaIncomingReceiptEvent, WaIncomingUnhandledStanzaEvent, WaGroupEvent } from './types';
+import type { Logger } from '../infra/log/types';
+import type { BinaryNode } from '../transport/types';
+interface IncomingAckRuntime {
+    readonly logger: Logger;
+    readonly sendNode: (node: BinaryNode) => Promise<void>;
+}
+type IncomingReceiptHandlerOptions = IncomingAckRuntime & {
+    readonly handleIncomingRetryReceipt?: (node: BinaryNode) => Promise<void>;
+    readonly trackOutboundReceipt?: (node: BinaryNode) => Promise<void>;
+    readonly emitIncomingReceipt: (event: WaIncomingReceiptEvent) => void;
+};
+type IncomingFailureHandlerOptions = {
+    readonly logger: Logger;
+    readonly emitIncomingFailure: (event: WaIncomingFailureEvent) => void;
+    readonly disconnect: () => Promise<void>;
+    readonly clearStoredCredentials: () => Promise<void>;
+};
+type IncomingNotificationHandlerOptions = IncomingAckRuntime & {
+    readonly emitIncomingNotification: (event: WaIncomingNotificationEvent) => void;
+    readonly emitUnhandledStanza: (event: WaIncomingUnhandledStanzaEvent) => void;
+    readonly syncAppState?: () => Promise<void>;
+};
+type IncomingGroupNotificationHandlerOptions = IncomingAckRuntime & {
+    readonly emitGroupEvent: (event: WaGroupEvent) => void;
+    readonly emitUnhandledStanza: (event: WaIncomingUnhandledStanzaEvent) => void;
+};
+export declare function createIncomingBaseEvent(node: BinaryNode): WaIncomingBaseEvent;
+export declare function createIncomingReceiptHandler(options: IncomingReceiptHandlerOptions): (node: BinaryNode) => Promise<boolean>;
+export declare function createIncomingFailureHandler(options: IncomingFailureHandlerOptions): (node: BinaryNode) => Promise<boolean>;
+export declare function createIncomingNotificationHandler(options: IncomingNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
+export declare function createIncomingGroupNotificationHandler(options: IncomingGroupNotificationHandlerOptions): (node: BinaryNode) => Promise<boolean>;
+export declare function createInfoBulletinNotificationEvent(node: BinaryNode, type: string, details?: Readonly<Record<string, unknown>>): WaIncomingNotificationEvent;
+export declare function createUnhandledIncomingNodeEvent(node: BinaryNode, reason?: string): WaIncomingUnhandledStanzaEvent;
+export {};

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

@@ -0,0 +1,2 @@
+export { WaClient } from './WaClient';
+export type { WaChatEvent, WaChatEventAction, WaChatEventSource, WaClientEventMap, WaClientOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from './types';

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

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

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

@@ -0,0 +1,17 @@
+import type { Logger } from '../infra/log/types';
+import type { WaMediaConn } from '../media/types';
+import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
+import type { WaSendMessageContent } from '../message/types';
+import type { Proto } from '..';
+import type { BinaryNode } from '../transport/types';
+interface WaMediaMessageOptions {
+    readonly logger: Logger;
+    readonly mediaTransfer: WaMediaTransferClient;
+    readonly iqTimeoutMs?: number;
+    readonly queryWithContext: (context: string, node: BinaryNode, timeoutMs?: number, contextData?: Readonly<Record<string, unknown>>) => Promise<BinaryNode>;
+    readonly getMediaConnCache: () => WaMediaConn | null;
+    readonly setMediaConnCache: (mediaConn: WaMediaConn | null) => void;
+}
+export declare function buildMediaMessageContent(options: WaMediaMessageOptions, content: WaSendMessageContent): Promise<Proto.IMessage>;
+export declare function getMediaConn(options: WaMediaMessageOptions, forceRefresh?: boolean): Promise<WaMediaConn>;
+export {};

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

@@ -0,0 +1,235 @@
+import type { AppStateCollectionName } from '../appstate/types';
+import type { WaAuthClientOptions, WaAuthCredentials, WaAuthSocketOptions } from '../auth/types';
+import type { WaMessagePublishOptions } from '../message/types';
+import type { Proto } from '..';
+import type { WaStore } from '../store/types';
+import type { BinaryNode } from '../transport/types';
+export interface WaClientOptions extends WaAuthClientOptions, WaAuthSocketOptions {
+    readonly store: WaStore;
+    readonly sessionId: string;
+    readonly chatSocketUrls?: readonly string[];
+    readonly iqTimeoutMs?: number;
+    readonly nodeQueryTimeoutMs?: number;
+    readonly keepAliveIntervalMs?: number;
+    readonly deadSocketTimeoutMs?: number;
+    readonly mediaTimeoutMs?: number;
+    readonly appStateSyncTimeoutMs?: number;
+    readonly signalFetchKeyBundlesTimeoutMs?: number;
+    readonly messageAckTimeoutMs?: number;
+    readonly messageMaxAttempts?: number;
+    readonly messageRetryDelayMs?: number;
+    readonly history?: WaHistorySyncOptions;
+    readonly chatEvents?: {
+        readonly emitSnapshotMutations?: boolean;
+    };
+}
+export interface WaHistorySyncOptions {
+    readonly enabled?: boolean;
+    readonly requireFullSync?: boolean;
+}
+export interface WaSignalMessagePublishInput {
+    readonly to: string;
+    readonly plaintext: Uint8Array;
+    readonly expectedIdentity?: Uint8Array;
+    readonly id?: string;
+    readonly type?: string;
+    readonly category?: string;
+    readonly pushPriority?: string;
+    readonly participant?: string;
+    readonly deviceFanout?: string;
+}
+export interface WaSendMessageOptions extends WaMessagePublishOptions {
+    readonly id?: string;
+    readonly expectedIdentity?: Uint8Array;
+}
+export type WaIncomingNodeHandler = (node: BinaryNode) => Promise<boolean>;
+export interface WaIncomingNodeHandlerRegistration {
+    readonly tag: string;
+    readonly subtype?: string;
+    readonly handler: WaIncomingNodeHandler;
+    readonly prepend?: boolean;
+}
+export interface WaIncomingBaseEvent {
+    readonly rawNode: BinaryNode;
+    readonly stanzaId?: string;
+    readonly chatJid?: string;
+    readonly stanzaType?: string;
+}
+export interface WaIncomingMessageEvent extends WaIncomingBaseEvent {
+    readonly timestampSeconds?: number;
+    readonly senderJid?: string;
+    readonly encryptionType?: string;
+    readonly isGroupChat: boolean;
+    readonly isBroadcastChat: boolean;
+    readonly plaintext?: Uint8Array;
+    readonly message?: Proto.IMessage;
+}
+export interface WaIncomingProtocolMessageEvent extends WaIncomingMessageEvent {
+    readonly protocolMessage: Proto.Message.IProtocolMessage;
+}
+export interface WaIncomingReceiptEvent extends WaIncomingBaseEvent {
+    readonly participantJid?: string;
+    readonly recipientJid?: string;
+}
+export interface WaIncomingPresenceEvent extends WaIncomingBaseEvent {
+}
+export interface WaIncomingChatstateEvent extends WaIncomingBaseEvent {
+    readonly participantJid?: string;
+}
+export interface WaIncomingCallEvent extends WaIncomingBaseEvent {
+}
+export interface WaIncomingNotificationEvent extends WaIncomingBaseEvent {
+    readonly notificationType?: string;
+    readonly classification?: 'core' | 'out_of_scope' | 'unknown' | 'info_bulletin';
+    readonly details?: Readonly<Record<string, unknown>>;
+}
+export interface WaIncomingFailureEvent extends WaIncomingBaseEvent {
+    readonly failureReason?: number;
+    readonly failureCode?: number;
+    readonly failureMessage?: string;
+    readonly failureUrl?: string;
+}
+export interface WaIncomingUnhandledStanzaEvent extends WaIncomingBaseEvent {
+    readonly reason: string;
+}
+export type WaGroupEventAction = 'create' | 'add' | 'delete' | 'remove' | 'promote' | 'demote' | 'linked_group_promote' | 'linked_group_demote' | 'modify' | 'subject' | 'description' | 'restrict' | 'announce' | 'no_frequently_forwarded' | 'invite' | 'ephemeral' | 'revoke_invite' | 'suspend' | 'growth_locked' | 'growth_unlocked' | 'link' | 'unlink' | 'membership_approval_mode' | 'membership_approval_request' | 'created_membership_requests' | 'revoked_membership_requests' | 'allow_non_admin_sub_group_creation' | 'allow_admin_reports' | 'admin_reports' | 'created_sub_group_suggestion' | 'revoked_sub_group_suggestions' | 'change_number' | 'member_add_mode' | 'auto_add_disabled' | 'is_capi_hosted_group' | 'group_safety_check' | 'limit_sharing_enabled' | 'missing_participant_identification';
+export interface WaGroupEventParticipant {
+    readonly jid?: string;
+    readonly role?: string;
+    readonly lidJid?: string;
+    readonly phoneJid?: string;
+    readonly displayName?: string;
+    readonly username?: string;
+    readonly expirationSeconds?: number;
+}
+export interface WaGroupEventLinkedGroup {
+    readonly jid?: string;
+    readonly subject?: string;
+    readonly subjectTimestampSeconds?: number;
+    readonly hiddenSubgroup?: boolean;
+}
+export interface WaGroupEventMembershipRequest {
+    readonly jid?: string;
+    readonly username?: string;
+    readonly phoneJid?: string;
+}
+export interface WaGroupEventSubgroupSuggestion {
+    readonly groupJid?: string;
+    readonly ownerJid?: string;
+    readonly subject?: string;
+    readonly description?: string;
+    readonly timestampSeconds?: number;
+    readonly isExistingGroup?: boolean;
+    readonly participantCount?: number;
+    readonly reason?: string;
+}
+export interface WaGroupEvent extends WaIncomingBaseEvent {
+    readonly rawActionNode: BinaryNode;
+    readonly groupJid?: string;
+    readonly authorJid?: string;
+    readonly timestampSeconds?: number;
+    readonly action: WaGroupEventAction;
+    readonly participants?: readonly WaGroupEventParticipant[];
+    readonly linkedGroups?: readonly WaGroupEventLinkedGroup[];
+    readonly membershipRequests?: readonly WaGroupEventMembershipRequest[];
+    readonly subgroupSuggestions?: readonly WaGroupEventSubgroupSuggestion[];
+    readonly contextGroupJid?: string;
+    readonly requestMethod?: string;
+    readonly subject?: string;
+    readonly subjectOwnerJid?: string;
+    readonly description?: string;
+    readonly descriptionId?: string;
+    readonly code?: string;
+    readonly expirationSeconds?: number;
+    readonly mode?: string;
+    readonly enabled?: boolean;
+    readonly reason?: string;
+    readonly details?: Readonly<Record<string, unknown>>;
+}
+export interface WaHistorySyncChunkEvent {
+    readonly syncType: number;
+    readonly messagesCount: number;
+    readonly conversationsCount: number;
+    readonly pushnamesCount: number;
+    readonly chunkOrder?: number;
+    readonly progress?: number;
+}
+export type WaChatEventAction = 'archive' | 'mute' | 'pin' | 'mark_read' | 'clear' | 'delete' | 'lock' | 'chat_assignment' | (string & {});
+export type WaChatEventSource = 'snapshot' | 'patch';
+export interface WaChatEvent {
+    readonly action: WaChatEventAction;
+    readonly source: WaChatEventSource;
+    readonly collection: AppStateCollectionName;
+    readonly operation: 'set' | 'remove';
+    readonly mutationIndex: string;
+    readonly indexAction?: string;
+    readonly indexParts?: readonly string[];
+    readonly syncActionValueKey?: string;
+    readonly chatJid?: string;
+    readonly timestamp: number;
+    readonly version: number;
+    readonly archived?: boolean;
+    readonly muted?: boolean;
+    readonly muteEndTimestampMs?: number;
+    readonly pinned?: boolean;
+    readonly read?: boolean;
+    readonly deleteStarred?: boolean;
+    readonly deleteMedia?: boolean;
+    readonly locked?: boolean;
+    readonly deviceAgentId?: string;
+}
+export type WaEmptyEvent = Readonly<Record<string, never>>;
+export interface WaClientEventMap {
+    readonly auth_qr: (event: {
+        readonly qr: string;
+        readonly ttlMs: number;
+    }) => void;
+    readonly auth_pairing_code: (event: {
+        readonly code: string;
+    }) => void;
+    readonly auth_pairing_refresh: (event: {
+        readonly forceManual: boolean;
+    }) => void;
+    readonly auth_paired: (event: {
+        readonly credentials: WaAuthCredentials;
+    }) => void;
+    readonly connection_success: (event: {
+        readonly node: BinaryNode;
+    }) => void;
+    readonly client_error: (event: {
+        readonly error: Error;
+    }) => void;
+    readonly connection_open: (event: WaEmptyEvent) => void;
+    readonly connection_close: (event: WaEmptyEvent) => void;
+    readonly transport_frame_in: (event: {
+        readonly frame: Uint8Array;
+    }) => void;
+    readonly transport_frame_out: (event: {
+        readonly frame: Uint8Array;
+    }) => void;
+    readonly transport_node_in: (event: {
+        readonly node: BinaryNode;
+        readonly frame: Uint8Array;
+    }) => void;
+    readonly transport_node_out: (event: {
+        readonly node: BinaryNode;
+        readonly frame: Uint8Array;
+    }) => void;
+    readonly transport_decode_error: (event: {
+        readonly error: Error;
+        readonly frame: Uint8Array;
+    }) => void;
+    readonly message: (event: WaIncomingMessageEvent) => void;
+    readonly message_protocol: (event: WaIncomingProtocolMessageEvent) => void;
+    readonly message_receipt: (event: WaIncomingReceiptEvent) => void;
+    readonly presence: (event: WaIncomingPresenceEvent) => void;
+    readonly chatstate: (event: WaIncomingChatstateEvent) => void;
+    readonly call: (event: WaIncomingCallEvent) => void;
+    readonly notification: (event: WaIncomingNotificationEvent) => void;
+    readonly failure: (event: WaIncomingFailureEvent) => void;
+    readonly stanza_error: (event: WaIncomingBaseEvent) => void;
+    readonly stanza_unhandled: (event: WaIncomingUnhandledStanzaEvent) => void;
+    readonly group_event: (event: WaGroupEvent) => void;
+    readonly chat_event: (event: WaChatEvent) => void;
+    readonly history_sync_chunk: (event: WaHistorySyncChunkEvent) => void;
+}

package/dist/types/crypto/core/constants.d.ts

@@ -0,0 +1 @@
+export declare const SERIALIZED_PUB_KEY_PREFIX = 5;

package/dist/types/crypto/core/encoding.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Base64 URL encoding utilities
+ */
+/**
+ * Decodes a base64url encoded string to Uint8Array
+ */
+export declare function decodeBase64Url(value: string | undefined, field: string): Uint8Array;
+/**
+ * Asserts that a Uint8Array is exactly 32 bytes
+ */
+export declare function assert32(value: Uint8Array, name: string): void;

package/dist/types/crypto/core/hkdf.d.ts

@@ -0,0 +1,8 @@
+/**
+ * HKDF key derivation using SHA-256
+ */
+export declare function hkdf(ikm: Uint8Array, salt: Uint8Array | null, info: Uint8Array | string, outLength: number): Promise<Uint8Array>;
+/**
+ * HKDF key derivation that outputs two 32-byte keys
+ */
+export declare function hkdfSplit(ikm: Uint8Array, salt: Uint8Array | null, info: string): Promise<readonly [Uint8Array, Uint8Array]>;

package/dist/types/crypto/core/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cryptographic utilities
+ */
+export { Ed25519 } from '../curves/Ed25519';
+export { X25519 } from '../curves/X25519';
+export { decodeBase64Url, assert32 } from '../core/encoding';
+export { hkdf, hkdfSplit } from '../core/hkdf';
+export { toSerializedPubKey, toRawPubKey, prependVersion, readVersionedContent } from '../core/keys';
+export { buildNonce } from '../core/nonce';
+export { randomBytesAsync, randomIntAsync } from '../core/random';
+export { type CryptoKey, sha1, sha256, sha512, importAesGcmKey, aesGcmEncrypt, aesGcmDecrypt, importAesCbcKey, aesCbcEncrypt, aesCbcDecrypt, importHmacKey, importHmacSha512Key, hmacSign, pbkdf2DeriveAesCtrKey, aesCtrEncrypt, aesCtrDecrypt, ed25519VerifyRaw } from '../core/primitives';

package/dist/types/crypto/core/keys.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a 32-byte raw public key to 33-byte serialized format (with 0x05 prefix)
+ */
+export declare function toSerializedPubKey(key: Uint8Array): Uint8Array;
+/**
+ * Converts a 33-byte serialized public key to 32-byte raw format
+ */
+export declare function toRawPubKey(key: Uint8Array): Uint8Array;
+/**
+ * Creates a version byte from high and low nibbles
+ */
+export declare function versionByte(high: number, low: number): number;
+/**
+ * Prepends a version byte to content
+ */
+export declare function prependVersion(content: Uint8Array, version: number): Uint8Array;
+/**
+ * Reads versioned content, validating the version and extracting the body
+ */
+export declare function readVersionedContent(versionContent: Uint8Array, expectedVersion: number, suffixLength: number): Uint8Array;

package/dist/types/crypto/core/nonce.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Builds a 12-byte nonce for AES-GCM encryption with counter in the last 4 bytes.
+ * Throws if counter exceeds uint32 range to prevent nonce reuse.
+ */
+export declare function buildNonce(counter: number): Uint8Array;