zapo-js 0.3.0 → 1.0.0

package/dist/transport/node/mex/persist-ids.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WA_MEX_PERSIST_IDS = void 0;
-exports.WA_MEX_PERSIST_IDS = Object.freeze({
-    WWWGetCertificates: Object.freeze({
-        docId: '25094190163544446',
-        clientDocId: '16428758503015954638431529919'
-    }),
-    WWWCreateUser: Object.freeze({
-        docId: '8548056818544135',
-        clientDocId: '25777518041400352865446016972'
-    })
-});

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

@@ -1,70 +0,0 @@
-import type { AppStateCollectionName, WaAppStateMissingKeysEvent, WaAppStateStoreData, WaAppStateSyncKey, WaAppStateSyncOptions, WaAppStateSyncResult } from './types';
-import type { Logger } from '../infra/log/types';
-import { type Proto } from '..';
-import type { WaAppStateStore } from '../store/contracts/appstate.store';
-import type { BinaryNode } from '../transport/types';
-interface WaAppStateSyncClientOptions {
-    readonly logger: Logger;
-    readonly query: (node: BinaryNode, timeoutMs: number) => Promise<BinaryNode>;
-    readonly store: WaAppStateStore;
-    readonly getCurrentMeJid?: () => string | null | undefined;
-    readonly hostDomain?: string;
-    readonly defaultTimeoutMs?: number;
-    readonly onMissingKeys?: (event: WaAppStateMissingKeysEvent) => Promise<void>;
-    readonly skipMacVerification?: boolean;
-    readonly mobilePrimary?: boolean;
-}
-export declare class WaAppStateMissingKeyError extends Error {
-    readonly keyId: Uint8Array | null;
-    readonly collection: AppStateCollectionName;
-    constructor(message: string, keyId: Uint8Array | null, collection: AppStateCollectionName);
-}
-export declare class WaAppStateSyncClient {
-    private readonly logger;
-    private readonly query;
-    private readonly store;
-    private readonly getCurrentMeJid?;
-    private readonly hostDomain;
-    private readonly defaultTimeoutMs;
-    private readonly onMissingKeys?;
-    private readonly crypto;
-    private readonly mobilePrimary;
-    private syncContext;
-    private syncPromise;
-    constructor(options: WaAppStateSyncClientOptions);
-    exportState(): Promise<WaAppStateStoreData>;
-    ensureInitialSyncKey(): Promise<WaAppStateSyncKey>;
-    importSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
-    importSyncKeyShare(share: Proto.Message.IAppStateSyncKeyShare): Promise<number>;
-    sync(options?: WaAppStateSyncOptions): Promise<WaAppStateSyncResult>;
-    private syncOnce;
-    private syncCollectionsRound;
-    private buildCollectionSyncRequest;
-    private buildSyncIqNode;
-    private fetchSyncPayloadByCollection;
-    private processCollectionRound;
-    private createCollectionOutcome;
-    private notifyMissingKeys;
-    private resolveReadyPatches;
-    private validateSnapshot;
-    private parseCollectionPatchVersion;
-    private validatePatch;
-    private applySnapshot;
-    private applyPatch;
-    private decryptSnapshotRecords;
-    private decryptPatchMutations;
-    private assertPatchMacsMatch;
-    private buildOutgoingPatch;
-    private resolveDeviceIndex;
-    private buildPatchClientDebugData;
-    private computeNextCollectionState;
-    private normalizeProtoLong;
-    private groupPendingMutations;
-    private preloadKeyData;
-    private getKeyData;
-    private getCollectionState;
-    private setCollectionState;
-    private persistCollectionUpdates;
-    private requireSyncContext;
-}
-export {};

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

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

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

@@ -1,20 +0,0 @@
-import type { WriteBehindPersistence } from './persistence/WriteBehindPersistence';
-import type { WaClientEventMap } from './types';
-import type { Logger } from '../infra/log/types';
-import type { WaMediaTransferClient } from '../media/WaMediaTransferClient';
-import { type Proto } from '..';
-interface WaHistorySyncDeps {
-    readonly logger: Logger;
-    readonly mediaTransfer: WaMediaTransferClient;
-    readonly writeBehind: WriteBehindPersistence;
-    readonly emitEvent: <K extends keyof WaClientEventMap>(event: K, ...args: Parameters<WaClientEventMap[K]>) => void;
-    readonly onPrivacyTokens?: (conversations: readonly {
-        readonly jid: string;
-        readonly tcToken?: Uint8Array | null;
-        readonly tcTokenTimestamp?: number | null;
-        readonly tcTokenSenderTimestamp?: number | null;
-    }[]) => Promise<void>;
-    readonly onNctSalt?: (salt: Uint8Array) => Promise<void>;
-}
-export declare function processHistorySyncNotification(deps: WaHistorySyncDeps, notification: Proto.Message.IHistorySyncNotification): Promise<void>;
-export {};

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

@@ -1,18 +0,0 @@
-import type { WaMediaOptions } from './types';
-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';
-export 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;
-    readonly media?: WaMediaOptions;
-}
-export declare function buildMediaMessageContent(options: WaMediaMessageOptions, content: WaSendMessageContent): Promise<Proto.IMessage>;
-export declare function getMediaConn(options: WaMediaMessageOptions, forceRefresh?: boolean): Promise<WaMediaConn>;

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

@@ -1,13 +0,0 @@
-import type { WaGroupEvent } from '../types';
-import type { Logger } from '../../infra/log/types';
-import type { WaParticipantsStore } from '../../store/contracts/participants.store';
-export type GroupParticipantsCache = {
-    resolveParticipantUsers(groupJid: string): Promise<readonly string[]>;
-    refreshParticipantUsers(groupJid: string): Promise<readonly string[]>;
-    mutateFromGroupEvent(event: WaGroupEvent): Promise<void>;
-};
-export declare function createGroupParticipantsCache(options: {
-    readonly participantsStore: WaParticipantsStore;
-    readonly queryGroupParticipantJids: (groupJid: string) => Promise<readonly string[]>;
-    readonly logger: Logger;
-}): GroupParticipantsCache;

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

@@ -1,22 +0,0 @@
-import { type Readable } from 'node:stream';
-import type { MediaCryptoType, WaMediaDecryptionResult, WaMediaDecryptReadableOptions, WaMediaDerivedKeys, WaMediaEncryptionResult, WaMediaFileEncryptionResult, WaMediaReadableDecryptionResult, WaMediaReadableEncryptionResult } from './types';
-export declare class WaMediaCrypto {
-    static generateMediaKey(): Promise<Uint8Array>;
-    static deriveKeys(mediaType: MediaCryptoType, mediaKey: Uint8Array): Promise<WaMediaDerivedKeys>;
-    static encryptBytes(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Uint8Array, options?: {
-        readonly sidecar?: boolean;
-        readonly firstFrameLength?: number;
-    }): Promise<WaMediaEncryptionResult>;
-    static decryptBytes(mediaType: MediaCryptoType, mediaKey: Uint8Array, ciphertextHmac: Uint8Array, expectedFileSha256?: Uint8Array, expectedFileEncSha256?: Uint8Array, skipMacVerification?: boolean): Promise<WaMediaDecryptionResult>;
-    static encryptReadable(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Readable, options?: {
-        readonly sidecar?: boolean;
-        readonly firstFrameLength?: number;
-    }): Promise<WaMediaReadableEncryptionResult>;
-    static encryptToFile(mediaType: MediaCryptoType, mediaKey: Uint8Array, plaintext: Readable, options?: {
-        readonly sidecar?: boolean;
-        readonly firstFrameLength?: number;
-    }): Promise<WaMediaFileEncryptionResult>;
-    static cleanupEncryptedFile(filePath: string): Promise<void>;
-    static decryptReadable(encrypted: Readable, options: WaMediaDecryptReadableOptions): Promise<WaMediaReadableDecryptionResult>;
-    static encryptedLength(plaintextLength: number): number;
-}

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

@@ -1,3 +0,0 @@
-import type { WaMediaConn } from './types';
-import type { BinaryNode } from '../transport/types';
-export declare function parseMediaConnResponse(node: BinaryNode, nowMs: number): WaMediaConn;

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

@@ -1,14 +0,0 @@
-import type { WaSendMediaMessage } from './types';
-import { type Proto } from '..';
-export declare function isSendMediaMessage(content: unknown): content is WaSendMediaMessage;
-export declare function unwrapMessage(message: Proto.IMessage): Proto.IMessage;
-export declare function resolveMessageTypeAttr(message: Proto.IMessage): string;
-export declare function needsSecretPersistence(message: Proto.IMessage): boolean;
-export declare function resolveEditAttr(message: Proto.IMessage, subtype?: string): string | null;
-export declare function resolveEncMediaType(message: Proto.IMessage): string | null;
-export interface MessageMetaAttrs {
-    readonly polltype?: string;
-    readonly event_type?: string;
-    readonly view_once?: string;
-}
-export declare function resolveMetaAttrs(message: Proto.IMessage): MessageMetaAttrs | null;

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

@@ -1,18 +0,0 @@
-import type { WaIncomingMessageEvent, WaIncomingUnhandledStanzaEvent } from '../client/types';
-import type { Logger } from '../infra/log/types';
-import type { WaRetryDecryptFailureContext } from '../retry/types';
-import type { SenderKeyManager } from '../signal/group/SenderKeyManager';
-import type { SignalProtocol } from '../signal/session/SignalProtocol';
-import type { BinaryNode } from '../transport/types';
-interface WaIncomingMessageAckHandlerOptions {
-    readonly logger: Logger;
-    readonly sendNode: (node: BinaryNode) => Promise<void>;
-    readonly getMeJid?: () => string | null | undefined;
-    readonly signalProtocol?: SignalProtocol;
-    readonly senderKeyManager?: SenderKeyManager;
-    readonly onDecryptFailure?: (context: WaRetryDecryptFailureContext, error: unknown) => Promise<boolean>;
-    readonly emitIncomingMessage?: (event: WaIncomingMessageEvent) => void;
-    readonly emitUnhandledStanza?: (event: WaIncomingUnhandledStanzaEvent) => void;
-}
-export declare function handleIncomingMessageAck(node: BinaryNode, options: WaIncomingMessageAckHandlerOptions): Promise<boolean>;
-export {};

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

@@ -1,4 +0,0 @@
-export declare const ADV_PREFIX_ACCOUNT_SIGNATURE: Uint8Array<ArrayBuffer>;
-export declare const ADV_PREFIX_DEVICE_SIGNATURE: Uint8Array<ArrayBuffer>;
-export declare const ADV_PREFIX_HOSTED_ACCOUNT_SIGNATURE: Uint8Array<ArrayBuffer>;
-export declare const ADV_PREFIX_HOSTED_DEVICE_SIGNATURE: Uint8Array<ArrayBuffer>;

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

@@ -1,13 +0,0 @@
-export interface WaParticipantsSnapshot {
-    readonly groupJid: string;
-    readonly participants: readonly string[];
-    readonly updatedAtMs: number;
-}
-export interface WaParticipantsStore {
-    destroy?(): Promise<void>;
-    upsertGroupParticipants(snapshot: WaParticipantsSnapshot): Promise<void>;
-    getGroupParticipants(groupJid: string, nowMs?: number): Promise<WaParticipantsSnapshot | null>;
-    deleteGroupParticipants(groupJid: string): Promise<number>;
-    cleanupExpired(nowMs: number): Promise<number>;
-    clear(): Promise<void>;
-}

package/dist/types/store/locks/participants.lock.d.ts

@@ -1,2 +0,0 @@
-import type { WaParticipantsStore } from '../contracts/participants.store';
-export declare function withParticipantsLock(store: WaParticipantsStore): WaParticipantsStore;

package/dist/types/store/providers/memory/participants.store.d.ts

@@ -1,17 +0,0 @@
-import type { WaParticipantsSnapshot, WaParticipantsStore } from '../../contracts/participants.store';
-export interface WaParticipantsMemoryStoreOptions {
-    readonly maxGroups?: number;
-}
-export declare class WaParticipantsMemoryStore implements WaParticipantsStore {
-    private readonly records;
-    private readonly ttlMs;
-    private readonly maxGroups;
-    private readonly cleanupTimer;
-    constructor(ttlMs?: number, options?: WaParticipantsMemoryStoreOptions);
-    upsertGroupParticipants(snapshot: WaParticipantsSnapshot): Promise<void>;
-    getGroupParticipants(groupJid: string, nowMs?: number): Promise<WaParticipantsSnapshot | null>;
-    deleteGroupParticipants(groupJid: string): Promise<number>;
-    cleanupExpired(nowMs: number): Promise<number>;
-    clear(): Promise<void>;
-    destroy(): Promise<void>;
-}

package/dist/types/transport/node/mex/persist-ids.d.ts

@@ -1,14 +0,0 @@
-export interface WaMexPersistId {
-    readonly docId: string;
-    readonly clientDocId: string;
-}
-export declare const WA_MEX_PERSIST_IDS: Readonly<{
-    WWWGetCertificates: Readonly<{
-        docId: "25094190163544446";
-        clientDocId: "16428758503015954638431529919";
-    }>;
-    WWWCreateUser: Readonly<{
-        docId: "8548056818544135";
-        clientDocId: "25777518041400352865446016972";
-    }>;
-}>;