zapo-js 0.1.0 → 0.1.2

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

@@ -3,10 +3,16 @@ import type { WaAuthClientOptions, WaAuthCredentials, WaAuthSocketOptions } from
 import type { WaMessagePublishOptions } from '../message/types';
 import type { Proto } from '..';
 import type { WaStore } from '../store/types';
-import type { BinaryNode } from '../transport/types';
+import type { BinaryNode, WaProxyTransport } from '../transport/types';
+export interface WaClientProxyOptions {
+    readonly ws?: WaProxyTransport;
+    readonly mediaUpload?: WaProxyTransport;
+    readonly mediaDownload?: WaProxyTransport;
+}
 export interface WaClientOptions extends WaAuthClientOptions, WaAuthSocketOptions {
     readonly store: WaStore;
     readonly sessionId: string;
+    readonly proxy?: WaClientProxyOptions;
     readonly chatSocketUrls?: readonly string[];
     readonly iqTimeoutMs?: number;
     readonly nodeQueryTimeoutMs?: number;
@@ -42,6 +48,23 @@ export interface WaSendMessageOptions extends WaMessagePublishOptions {
     readonly id?: string;
     readonly expectedIdentity?: Uint8Array;
 }
+export interface WaClearChatOptions {
+    readonly deleteStarred?: boolean;
+    readonly deleteMedia?: boolean;
+}
+export interface WaDeleteChatOptions {
+    readonly deleteMedia?: boolean;
+}
+export interface WaAppStateMessageKey {
+    readonly chatJid: string;
+    readonly id: string;
+    readonly fromMe: boolean;
+    readonly participantJid?: string;
+}
+export interface WaDeleteMessageForMeOptions {
+    readonly deleteMedia?: boolean;
+    readonly messageTimestampMs?: number;
+}
 export type WaIncomingNodeHandler = (node: BinaryNode) => Promise<boolean>;
 export interface WaIncomingNodeHandlerRegistration {
     readonly tag: string;

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

@@ -1,8 +1,2 @@
-/**
- * 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

@@ -3,7 +3,6 @@
  */
 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';

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

@@ -1,8 +1,2 @@
-/**
- * Generates cryptographically secure random bytes
- */
 export declare function randomBytesAsync(size: number): Promise<Uint8Array>;
-/**
- * Generates a cryptographically secure random integer in the range [min, max)
- */
-export declare function randomIntAsync(min: number, max: number): Promise<number>;
+export declare const randomIntAsync: (min: number, max: number) => Promise<number>;

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

@@ -1,3 +1 @@
 export * from './core';
-export { Ed25519 } from './curves/Ed25519';
-export { X25519 } from './curves/X25519';

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export { WaClient } from '@client';
-export type { WaClientEventMap, WaClientOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from '@client';
+export type { WaClientEventMap, WaClientOptions, WaClientProxyOptions, WaHistorySyncChunkEvent, WaHistorySyncOptions } from '@client';
 export { ConsoleLogger } from './infra/log/ConsoleLogger';
 export { PinoLogger, createPinoLogger } from './infra/log/PinoLogger';
 export type { PinoLoggerOptions } from './infra/log/PinoLogger';

package/dist/types/infra/log/ConsoleLogger.d.ts

@@ -1,11 +1,12 @@
 import type { LogLevel, Logger } from '../log/types';
 export declare class ConsoleLogger implements Logger {
     readonly level: LogLevel;
+    private readonly minLevelPriority;
     constructor(level?: LogLevel);
     trace(message: string, context?: Record<string, unknown>): void;
     debug(message: string, context?: Record<string, unknown>): void;
     info(message: string, context?: Record<string, unknown>): void;
     warn(message: string, context?: Record<string, unknown>): void;
     error(message: string, context?: Record<string, unknown>): void;
-    private canLog;
+    private write;
 }

package/dist/types/infra/log/PinoLogger.d.ts

@@ -24,7 +24,7 @@ export declare class PinoLogger implements Logger {
     info(message: string, context?: Readonly<Record<string, unknown>>): void;
     warn(message: string, context?: Readonly<Record<string, unknown>>): void;
     error(message: string, context?: Readonly<Record<string, unknown>>): void;
-    private writeLog;
+    private write;
 }
 export declare function createPinoLogger(options?: PinoLoggerOptions): Promise<PinoLogger>;
 export {};

package/dist/types/infra/log/types.d.ts

@@ -7,3 +7,4 @@ export interface Logger {
     warn(message: string, context?: Readonly<Record<string, unknown>>): void;
     error(message: string, context?: Readonly<Record<string, unknown>>): void;
 }
+export declare function createNoopLogger(level?: LogLevel): Logger;

package/dist/types/infra/perf/BoundedTaskQueue.d.ts

@@ -10,10 +10,10 @@ export declare class BoundedTaskQueue {
     private head;
     private running;
     constructor(maxQueueSize?: number, maxConcurrency?: number);
+    private readonly settleTask;
     enqueue<T>(task: Task<T>): Promise<T>;
     pending(): number;
     inFlight(): number;
     private drain;
-    private compactIfNeeded;
 }
 export {};

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

@@ -5,6 +5,8 @@ interface StreamDownloadRequest {
     readonly directPath?: string;
     readonly hosts?: readonly string[];
     readonly headers?: Readonly<Record<string, string>>;
+    readonly dispatcher?: WaMediaTransferClientOptions['defaultDownloadDispatcher'];
+    readonly agent?: WaMediaTransferClientOptions['defaultDownloadAgent'];
     readonly timeoutMs?: number;
     readonly signal?: AbortSignal;
     readonly maxBytes?: number;
@@ -55,6 +57,11 @@ export declare class WaMediaTransferClient {
     private readonly defaultTimeoutMs;
     private readonly defaultMaxReadBytes;
     private readonly defaultHeaders;
+    private readonly defaultUploadDispatcher;
+    private readonly defaultDownloadDispatcher;
+    private readonly defaultUploadAgent;
+    private readonly defaultDownloadAgent;
+    private gotModulePromise;
     constructor(options?: WaMediaTransferClientOptions);
     downloadStream(request: StreamDownloadRequest): Promise<StreamTransferResponse>;
     downloadBytes(request: StreamDownloadRequest): Promise<Uint8Array>;
@@ -63,19 +70,22 @@ export declare class WaMediaTransferClient {
     downloadAndDecrypt(request: EncryptedDownloadRequest): Promise<Uint8Array>;
     downloadAndDecryptStream(request: EncryptedDownloadRequest): Promise<EncryptedDownloadStream>;
     readResponseBytes(response: StreamTransferResponse, maxBytes?: number): Promise<Uint8Array>;
+    private transferRequest;
+    private fetchWithDispatcher;
+    private toFetchTransferResponse;
+    private gotWithAgent;
+    private loadGotModule;
+    private toGotTransferResponse;
     private resolveTransferRequest;
     private executeTransfer;
     private prepareEncryptedUpload;
     private assertSuccessfulResponse;
     private requireResponseBody;
     private resolveUrls;
-    private mergeHeaders;
     private readAllBytesWithLimit;
     private fetchWithFallback;
     private createAbortContext;
-    private toResponse;
     private headersToRecord;
-    private cancelWebBody;
     private drainBody;
 }
 export {};

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

@@ -1,5 +1,6 @@
 import type { Readable } from 'node:stream';
 import type { Logger } from '../infra/log/types';
+import type { WaProxyAgent, WaProxyDispatcher } from '../transport/types';
 export type MediaKind = 'image' | 'video' | 'audio' | 'document' | 'sticker';
 export type MediaCryptoType = MediaKind | 'ptt' | 'gif' | 'ptv' | 'history' | 'md-app-state';
 export interface WaMediaConnHost {
@@ -17,6 +18,10 @@ export interface WaMediaTransferClientOptions {
     readonly defaultTimeoutMs?: number;
     readonly defaultMaxReadBytes?: number;
     readonly defaultHeaders?: Readonly<Record<string, string>>;
+    readonly defaultUploadDispatcher?: WaProxyDispatcher;
+    readonly defaultDownloadDispatcher?: WaProxyDispatcher;
+    readonly defaultUploadAgent?: WaProxyAgent;
+    readonly defaultDownloadAgent?: WaProxyAgent;
 }
 export interface WaMediaDerivedKeys {
     readonly iv: Uint8Array;

package/dist/types/message/addon-crypto.d.ts

@@ -0,0 +1,25 @@
+import { WA_USE_CASE_SECRET_MODIFICATION_TYPES } from './use-case-secret';
+type WaAddonBytes = Uint8Array | ArrayBuffer | ArrayBufferView;
+export declare function shouldUseAddonAdditionalData(modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES]): boolean;
+export declare function buildAddonAdditionalData(stanzaId: string, addOnSenderJid: string): Uint8Array;
+export declare function encryptAddonPayload(input: {
+    readonly messageSecret: WaAddonBytes;
+    readonly stanzaId: string;
+    readonly parentMsgOriginalSender: string;
+    readonly modificationSender: string;
+    readonly modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+    readonly payload: WaAddonBytes;
+    readonly iv: WaAddonBytes;
+    readonly additionalData?: WaAddonBytes;
+}): Promise<Uint8Array>;
+export declare function decryptAddonPayload(input: {
+    readonly messageSecret: WaAddonBytes;
+    readonly stanzaId: string;
+    readonly parentMsgOriginalSender: string;
+    readonly modificationSender: string;
+    readonly modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+    readonly ciphertext: WaAddonBytes;
+    readonly iv: WaAddonBytes;
+    readonly additionalData?: WaAddonBytes;
+}): Promise<Uint8Array>;
+export {};

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

@@ -1,2 +1,4 @@
 export { WaMessageClient } from './WaMessageClient';
+export * from './addon-crypto';
 export * from './types';
+export * from './use-case-secret';

package/dist/types/message/reporting-token.d.ts

@@ -0,0 +1,19 @@
+import { type Proto } from '..';
+import type { BinaryNode } from '../transport/types';
+export declare const WA_REPORTING_TOKEN_VERSION = 2;
+export interface BuildReportingTokenNodeInput {
+    readonly message: Proto.IMessage;
+    readonly stanzaId: string;
+    readonly senderUserJid: string;
+    readonly remoteJid: string;
+    readonly version?: number;
+}
+export interface BuildReportingTokenArtifactsResult {
+    readonly node: BinaryNode;
+    readonly version: number;
+    readonly reportingToken: Uint8Array;
+    readonly reportingTokenContent: Uint8Array;
+    readonly reportingTokenKey: Uint8Array;
+}
+export declare function buildReportingTokenNode(input: BuildReportingTokenNodeInput): Promise<BinaryNode | null>;
+export declare function buildReportingTokenArtifacts(input: BuildReportingTokenNodeInput): Promise<BuildReportingTokenArtifactsResult | null>;

package/dist/types/message/use-case-secret.d.ts

@@ -0,0 +1,20 @@
+import type { Proto } from '..';
+export declare const WA_MESSAGE_SECRET_BYTES = 32;
+export declare const WA_USE_CASE_SECRET_MODIFICATION_TYPES: Readonly<{
+    readonly POLL_VOTE: "Poll Vote";
+    readonly ENC_REACTION: "Enc Reaction";
+    readonly ENC_COMMENT: "Enc Comment";
+    readonly REPORT_TOKEN: "Report Token";
+    readonly EVENT_RESPONSE: "Event Response";
+    readonly EVENT_EDIT_ENCRYPTED: "Event Edit";
+    readonly MESSAGE_EDIT: "Message Edit";
+}>;
+export declare function assertMessageSecret(messageSecret: Uint8Array | ArrayBuffer | ArrayBufferView, context?: string): Uint8Array;
+export declare function ensureMessageSecret(message: Proto.IMessage): Promise<Proto.IMessage>;
+export declare function createUseCaseSecret(input: {
+    readonly messageSecret: Uint8Array | ArrayBuffer | ArrayBufferView;
+    readonly stanzaId: string;
+    readonly parentMsgOriginalSender: string;
+    readonly modificationSender: string;
+    readonly modificationType: (typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES)[keyof typeof WA_USE_CASE_SECRET_MODIFICATION_TYPES];
+}): Promise<Uint8Array>;

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

@@ -32,3 +32,61 @@ export declare const WA_APP_STATE_KDF_INFO: Readonly<{
     readonly MUTATION_KEYS: "WhatsApp Mutation Keys";
     readonly PATCH_INTEGRITY: "WhatsApp Patch Integrity";
 }>;
+export declare const WA_APP_STATE_CHAT_MUTATION_ACTIONS: Readonly<{
+    readonly STAR: "star";
+    readonly MUTE: "mute";
+    readonly PIN: "pin_v1";
+    readonly ARCHIVE: "archive";
+    readonly DELETE_MESSAGE_FOR_ME: "deleteMessageForMe";
+    readonly MARK_CHAT_AS_READ: "markChatAsRead";
+    readonly CLEAR_CHAT: "clearChat";
+    readonly DELETE_CHAT: "deleteChat";
+    readonly LOCK_CHAT: "lock";
+}>;
+export declare const WA_APP_STATE_CHAT_MUTATION_SPECS: Readonly<{
+    readonly STAR: {
+        readonly collection: "regular_high";
+        readonly action: "star";
+        readonly version: 2;
+    };
+    readonly MUTE: {
+        readonly collection: "regular_high";
+        readonly action: "mute";
+        readonly version: 2;
+    };
+    readonly PIN: {
+        readonly collection: "regular_low";
+        readonly action: "pin_v1";
+        readonly version: 5;
+    };
+    readonly ARCHIVE: {
+        readonly collection: "regular_low";
+        readonly action: "archive";
+        readonly version: 3;
+    };
+    readonly DELETE_MESSAGE_FOR_ME: {
+        readonly collection: "regular_high";
+        readonly action: "deleteMessageForMe";
+        readonly version: 3;
+    };
+    readonly MARK_CHAT_AS_READ: {
+        readonly collection: "regular_low";
+        readonly action: "markChatAsRead";
+        readonly version: 3;
+    };
+    readonly CLEAR_CHAT: {
+        readonly collection: "regular_high";
+        readonly action: "clearChat";
+        readonly version: 6;
+    };
+    readonly DELETE_CHAT: {
+        readonly collection: "regular_high";
+        readonly action: "deleteChat";
+        readonly version: 6;
+    };
+    readonly LOCK_CHAT: {
+        readonly collection: "regular_low";
+        readonly action: "lock";
+        readonly version: 7;
+    };
+}>;

package/dist/types/protocol/constants.d.ts

@@ -3,9 +3,10 @@ export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth';
 export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream';
 export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes';
 export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate';
+export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_CHAT_MUTATION_ACTIONS, WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate';
 export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media';
 export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty';
 export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification';
 export { WA_DEFAULTS } from './defaults';
 export { WA_GROUP_PARTICIPANT_TYPES, type WaGroupSetting } from './group';
+export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync';

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

@@ -1,11 +1,3 @@
-export { getWaCompanionPlatformId, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS } from './browser';
-export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth';
-export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream';
-export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes';
-export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate';
-export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media';
-export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty';
-export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification';
-export { WA_DEFAULTS } from './defaults';
+export * from './constants';
 export { getLoginIdentity, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid } from './jid';
+export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync';

package/dist/types/protocol/jid.d.ts

@@ -1,9 +1,8 @@
 import type { SignalAddress } from '../signal/types';
-export interface ParsedJid {
+export declare function splitJid(jid: string): {
     readonly user: string;
     readonly server: string;
-}
-export declare function splitJid(jid: string): ParsedJid;
+};
 export declare function normalizeRecipientJid(to: string): string;
 export declare function isJidType(jid: string, type: string): boolean;
 export declare function isGroupJid(jid: string): boolean;
@@ -17,3 +16,4 @@ export declare function getLoginIdentity(meJid: string): {
     readonly device: number;
 };
 export declare function parsePhoneJid(input: string): string;
+export declare function signalAddressKey(address: SignalAddress): string;

package/dist/types/protocol/nodes.d.ts

@@ -23,6 +23,8 @@ export declare const WA_NODE_TAGS: Readonly<{
     readonly KEY_FETCH: "key_fetch";
     readonly LIST: "list";
     readonly USER: "user";
+    readonly CONTACT: "contact";
+    readonly LID: "lid";
     readonly PICTURE: "picture";
     readonly PRIVACY: "privacy";
     readonly PARTICIPATING: "participating";

package/dist/types/protocol/usync.d.ts

@@ -0,0 +1,11 @@
+export declare const WA_USYNC_MODES: Readonly<{
+    readonly QUERY: "query";
+}>;
+export declare const WA_USYNC_CONTEXTS: Readonly<{
+    readonly INTERACTIVE: "interactive";
+    readonly NOTIFICATION: "notification";
+}>;
+export declare const WA_USYNC_DEFAULTS: Readonly<{
+    readonly INDEX: "0";
+    readonly LAST: "true";
+}>;

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

@@ -5,3 +5,4 @@ export { parseRetryReceiptRequest } from './parse';
 export type { WaParsedRetryRequest, WaRetryDecryptFailureContext, WaRetryEncryptedReplayPayload, WaRetryKey, WaRetryKeyBundle, WaRetryOpaqueNodeReplayPayload, WaRetryOutboundMessageRecord, WaRetryOutboundMode, WaRetryOutboundState, WaRetryPlaintextReplayPayload, WaRetryReceiptType, WaRetryReplayPayload, WaRetrySignedKey } from './types';
 export { decodeRetryReplayPayload, encodeRetryReplayPayload, pickRetryStateMax } from './outbound';
 export { WaRetryReplayService, type WaRetryReplayServiceOptions, type WaRetryResendResult } from './replay';
+export { createOutboundRetryTracker, type OutboundRetryTrackHint, type OutboundRetryTracker } from './tracker';

package/dist/types/retry/replay.d.ts

@@ -22,9 +22,5 @@ export declare class WaRetryReplayService {
     private resendOpaquePayload;
     private maybeWrapGroupRetryPlaintextForSelfDevice;
     private isRequesterCurrentAccount;
-    private get logger();
-    private get messageClient();
-    private get signalProtocol();
-    private getCurrentSignedIdentity;
     private isOpaqueReplayCompatible;
 }

package/dist/types/retry/tracker.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '../infra/log/types';
+import type { WaMessagePublishResult } from '../message/types';
+import type { WaRetryReplayPayload } from './types';
+import type { WaRetryStore } from '../store/contracts/retry.store';
+export type OutboundRetryTrackHint = {
+    readonly messageIdHint?: string;
+    readonly toJid?: string;
+    readonly type: string;
+    readonly replayPayload: WaRetryReplayPayload;
+    readonly participantJid?: string;
+    readonly recipientJid?: string;
+};
+export type OutboundRetryTracker = {
+    track(hint: OutboundRetryTrackHint, publish: () => Promise<WaMessagePublishResult>): Promise<WaMessagePublishResult>;
+};
+export declare function createOutboundRetryTracker(options: {
+    readonly retryStore: WaRetryStore;
+    readonly logger: Logger;
+}): OutboundRetryTracker;

package/dist/types/retry/types.d.ts

@@ -5,15 +5,16 @@ export type WaRetryOutboundState = 'pending' | 'delivered' | 'read' | 'played' |
 export interface WaRetryKey {
     readonly id: number;
     readonly publicKey: Uint8Array;
+    readonly signature?: Uint8Array;
 }
-export interface WaRetrySignedKey extends WaRetryKey {
+export type WaRetrySignedKey = WaRetryKey & {
     readonly signature: Uint8Array;
-}
+};
 export interface WaRetryKeyBundle {
     readonly identity: Uint8Array;
     readonly deviceIdentity?: Uint8Array;
     readonly key?: WaRetryKey;
-    readonly skey: WaRetrySignedKey;
+    readonly skey: WaRetryKey;
 }
 export interface WaParsedRetryRequest {
     readonly type: WaRetryReceiptType;

package/dist/types/signal/api/SignalDeviceSyncApi.d.ts

@@ -1,5 +1,6 @@
 import type { Logger } from '../../infra/log/types';
 import type { WaDeviceListStore } from '../../store/contracts/device-list.store';
+import { type WaUsyncSidGenerator } from '../../transport/node/usync';
 import type { BinaryNode } from '../../transport/types';
 interface SignalDeviceSyncApiOptions {
     readonly logger: Logger;
@@ -7,6 +8,12 @@ interface SignalDeviceSyncApiOptions {
     readonly deviceListStore?: WaDeviceListStore;
     readonly defaultTimeoutMs?: number;
     readonly hostDomain?: string;
+    readonly generateSid?: WaUsyncSidGenerator;
+}
+export interface SignalLidSyncResult {
+    readonly phoneJid: string;
+    readonly lidJid: string | null;
+    readonly exists: boolean;
 }
 export declare class SignalDeviceSyncApi {
     private readonly logger;
@@ -14,18 +21,23 @@ export declare class SignalDeviceSyncApi {
     private readonly deviceListStore?;
     private readonly defaultTimeoutMs;
     private readonly hostDomain;
+    private readonly generateSid;
     constructor(options: SignalDeviceSyncApiOptions);
     syncDeviceList(userJids: readonly string[], timeoutMs?: number): Promise<readonly {
         readonly jid: string;
         readonly deviceJids: readonly string[];
     }[]>;
+    queryLidsByPhoneJids(phoneJids: readonly string[], timeoutMs?: number): Promise<readonly SignalLidSyncResult[]>;
     private collectUsersToQuery;
     private makeDeviceSyncRequest;
+    private makeLidSyncRequest;
     private parseDeviceSyncResponse;
+    private parseLidSyncResponse;
+    private buildLidSyncResult;
+    private parseLidSyncContactExists;
     private parseUserDeviceJids;
     private normalizeUsers;
     private normalizeUserJid;
     private toDeviceJid;
-    private makeSid;
 }
 export {};

package/dist/types/signal/group/SenderKeyCodec.d.ts

@@ -1,14 +1,12 @@
-export interface ParsedDistributionPayload {
+export declare function parseDistributionPayload(payload: Uint8Array): {
     readonly keyId: number;
     readonly iteration: number;
     readonly chainKey: Uint8Array;
     readonly signingPublicKey: Uint8Array;
-}
-export interface ParsedSenderKeyMessage {
+};
+export declare function parseSenderKeyMessage(versionContentMac: Uint8Array): {
     readonly keyId: number;
     readonly iteration: number;
     readonly ciphertext: Uint8Array;
     readonly versionContentMac: Uint8Array;
-}
-export declare function parseDistributionPayload(payload: Uint8Array): ParsedDistributionPayload;
-export declare function parseSenderKeyMessage(versionContentMac: Uint8Array): ParsedSenderKeyMessage;
+};

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

@@ -10,3 +10,4 @@ export { SignalSessionSyncApi } from './api/SignalSessionSyncApi';
 export { SenderKeyManager } from './group/SenderKeyManager';
 export { createAndStoreInitialKeys } from './registration/utils';
 export { SignalProtocol } from './session/SignalProtocol';
+export { createSignalSessionResolver, type SignalSessionResolver } from './session/resolver';

package/dist/types/signal/session/SignalProtocol.d.ts

@@ -13,6 +13,15 @@ export declare class SignalProtocol {
         readonly ciphertext: Uint8Array;
         readonly baseKey: Uint8Array | null;
     }>;
+    encryptMessagesBatch(requests: readonly {
+        readonly address: SignalAddress;
+        readonly plaintext: Uint8Array;
+        readonly expectedIdentity?: Uint8Array;
+    }[]): Promise<readonly {
+        readonly type: 'msg' | 'pkmsg';
+        readonly ciphertext: Uint8Array;
+        readonly baseKey: Uint8Array | null;
+    }[]>;
     decryptMessage(address: SignalAddress, envelope: {
         readonly type: 'msg' | 'pkmsg';
         readonly ciphertext: Uint8Array;

package/dist/types/signal/session/resolver.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from '../../infra/log/types';
+import type { SignalIdentitySyncApi } from '../api/SignalIdentitySyncApi';
+import type { SignalSessionSyncApi } from '../api/SignalSessionSyncApi';
+import type { SignalProtocol } from '../session/SignalProtocol';
+import type { SignalAddress } from '../types';
+import type { WaSignalStore } from '../../store/contracts/signal.store';
+export type SignalSessionResolver = {
+    ensureSession(address: SignalAddress, jid: string, expectedIdentity?: Uint8Array, reasonIdentity?: boolean): Promise<void>;
+    ensureSessionsBatch(targetJids: readonly string[], expectedIdentityByJid?: ReadonlyMap<string, Uint8Array>): Promise<void>;
+};
+export declare function createSignalSessionResolver(options: {
+    readonly signalProtocol: SignalProtocol;
+    readonly signalStore: WaSignalStore;
+    readonly signalIdentitySync: SignalIdentitySyncApi;
+    readonly signalSessionSync: SignalSessionSyncApi;
+    readonly logger: Logger;
+}): SignalSessionResolver;

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

@@ -1,5 +1,6 @@
 import type { AppStateCollectionName, WaAppStateStoreData, WaAppStateSyncKey } from '../../appstate/types';
 export interface WaAppStateCollectionStoreState {
+    readonly initialized: boolean;
     readonly version: number;
     readonly hash: Uint8Array;
     readonly indexValueMap: ReadonlyMap<string, Uint8Array>;
@@ -15,8 +16,10 @@ export interface WaAppStateStore {
     upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
     getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
     getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
+    getSyncKeyDataBatch(keyIds: readonly Uint8Array[]): Promise<readonly (Uint8Array | null)[]>;
     getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;
     getCollectionState(collection: AppStateCollectionName): Promise<WaAppStateCollectionStoreState>;
+    getCollectionStates(collections: readonly AppStateCollectionName[]): Promise<readonly WaAppStateCollectionStoreState[]>;
     setCollectionStates(updates: readonly WaAppStateCollectionStateUpdate[]): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/types/store/contracts/contact.store.d.ts

@@ -8,6 +8,7 @@ export interface WaStoredContactRecord {
 }
 export interface WaContactStore {
     upsert(record: WaStoredContactRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredContactRecord[]): Promise<void>;
     getByJid(jid: string): Promise<WaStoredContactRecord | null>;
     deleteByJid(jid: string): Promise<number>;
     clear(): Promise<void>;

package/dist/types/store/contracts/device-list.store.d.ts

@@ -4,11 +4,8 @@ export interface WaDeviceListSnapshot {
     readonly updatedAtMs: number;
 }
 export interface WaDeviceListStore {
-    getTtlMs(): number;
     destroy?(): Promise<void>;
-    upsertUserDevices(snapshot: WaDeviceListSnapshot): Promise<void>;
     upsertUserDevicesBatch(snapshots: readonly WaDeviceListSnapshot[]): Promise<void>;
-    getUserDevices(userJid: string, nowMs?: number): Promise<WaDeviceListSnapshot | null>;
     getUserDevicesBatch(userJids: readonly string[], nowMs?: number): Promise<readonly (WaDeviceListSnapshot | null)[]>;
     deleteUserDevices(userJid: string): Promise<number>;
     cleanupExpired(nowMs: number): Promise<number>;

package/dist/types/store/contracts/message.store.d.ts

@@ -11,6 +11,7 @@ export interface WaStoredMessageRecord {
 }
 export interface WaMessageStore {
     upsert(record: WaStoredMessageRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredMessageRecord[]): Promise<void>;
     getById(id: string): Promise<WaStoredMessageRecord | null>;
     listByThread(threadJid: string, limit?: number, beforeTimestampMs?: number): Promise<readonly WaStoredMessageRecord[]>;
     deleteById(id: string): Promise<number>;

package/dist/types/store/contracts/participants.store.d.ts

@@ -4,7 +4,6 @@ export interface WaParticipantsSnapshot {
     readonly updatedAtMs: number;
 }
 export interface WaParticipantsStore {
-    getTtlMs(): number;
     destroy?(): Promise<void>;
     upsertGroupParticipants(snapshot: WaParticipantsSnapshot): Promise<void>;
     getGroupParticipants(groupJid: string, nowMs?: number): Promise<WaParticipantsSnapshot | null>;

package/dist/types/store/contracts/sender-key.store.d.ts

@@ -8,7 +8,6 @@ export interface WaSenderKeyStore {
         readonly skDistribList: readonly SenderKeyDistributionRecord[];
     }>;
     getDeviceSenderKey(groupId: string, sender: SignalAddress): Promise<SenderKeyRecord | null>;
-    getDeviceSenderKeyDistribution(groupId: string, sender: SignalAddress): Promise<SenderKeyDistributionRecord | null>;
     getDeviceSenderKeyDistributions(groupId: string, senders: readonly SignalAddress[]): Promise<readonly (SenderKeyDistributionRecord | null)[]>;
     deleteDeviceSenderKey(target: SignalAddress, groupId?: string): Promise<number>;
     markForgetSenderKey(groupId: string, participants: readonly SignalAddress[]): Promise<number>;