zapo-js 0.1.0

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

@@ -0,0 +1,21 @@
+import type { AppStateCollectionName, WaAppStateStoreData, WaAppStateSyncKey } from '../../../appstate/types';
+import type { WaAppStateCollectionStateUpdate, WaAppStateCollectionStoreState, WaAppStateStore } from '../../contracts/appstate.store';
+export interface WaAppStateMemoryStoreOptions {
+    readonly maxSyncKeys?: number;
+    readonly maxCollectionEntries?: number;
+}
+export declare class WaAppStateMemoryStore implements WaAppStateStore {
+    private readonly keys;
+    private readonly collections;
+    private readonly maxSyncKeys;
+    private readonly maxCollectionEntries;
+    constructor(initial?: WaAppStateStoreData, options?: WaAppStateMemoryStoreOptions);
+    exportData(): Promise<WaAppStateStoreData>;
+    upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
+    getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
+    getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
+    getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;
+    getCollectionState(collection: AppStateCollectionName): Promise<WaAppStateCollectionStoreState>;
+    setCollectionStates(updates: readonly WaAppStateCollectionStateUpdate[]): Promise<void>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import type { WaContactStore as Contract, WaStoredContactRecord } from '../../contracts/contact.store';
+export interface WaContactMemoryStoreOptions {
+    readonly maxContacts?: number;
+}
+export declare class WaContactMemoryStore implements Contract {
+    private readonly contacts;
+    private readonly maxContacts;
+    constructor(options?: WaContactMemoryStoreOptions);
+    upsert(record: WaStoredContactRecord): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredContactRecord | null>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/memory/device-list.store.d.ts

@@ -0,0 +1,20 @@
+import type { WaDeviceListSnapshot, WaDeviceListStore } from '../../contracts/device-list.store';
+export interface WaDeviceListMemoryStoreOptions {
+    readonly maxUsers?: number;
+}
+export declare class WaDeviceListMemoryStore implements WaDeviceListStore {
+    private readonly records;
+    private readonly ttlMs;
+    private readonly maxUsers;
+    private readonly cleanupTimer;
+    constructor(ttlMs?: number, options?: WaDeviceListMemoryStoreOptions);
+    getTtlMs(): number;
+    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>;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+}

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

@@ -0,0 +1,14 @@
+import type { WaMessageStore as Contract, WaStoredMessageRecord } from '../../contracts/message.store';
+export interface WaMessageMemoryStoreOptions {
+    readonly maxMessages?: number;
+}
+export declare class WaMessageMemoryStore implements Contract {
+    private readonly messages;
+    private readonly maxMessages;
+    constructor(options?: WaMessageMemoryStoreOptions);
+    upsert(record: WaStoredMessageRecord): Promise<void>;
+    getById(id: string): Promise<WaStoredMessageRecord | null>;
+    listByThread(threadJid: string, limit?: number, beforeTimestampMs?: number): Promise<readonly WaStoredMessageRecord[]>;
+    deleteById(id: string): Promise<number>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+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);
+    getTtlMs(): number;
+    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/store/providers/memory/retry.store.d.ts

@@ -0,0 +1,18 @@
+import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../../retry/types';
+import type { WaRetryStore } from '../../contracts/retry.store';
+export declare class WaRetryMemoryStore implements WaRetryStore {
+    private readonly outboundMessages;
+    private readonly inboundCounters;
+    private readonly ttlMs;
+    private readonly cleanupTimer;
+    constructor(ttlMs?: number);
+    getTtlMs(): number;
+    upsertOutboundMessage(record: WaRetryOutboundMessageRecord): Promise<void>;
+    getOutboundMessage(messageId: string): Promise<WaRetryOutboundMessageRecord | null>;
+    updateOutboundMessageState(messageId: string, state: WaRetryOutboundState, updatedAtMs: number, expiresAtMs: number): Promise<void>;
+    incrementInboundCounter(messageId: string, requesterJid: string, _updatedAtMs: number, expiresAtMs: number): Promise<number>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+    private counterKey;
+}

package/dist/types/store/providers/memory/sender-key.store.d.ts

@@ -0,0 +1,28 @@
+import type { SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress } from '../../../signal/types';
+import type { WaSenderKeyStore as WaSenderKeyStoreContract } from '../../contracts/sender-key.store';
+export interface WaSenderKeyMemoryStoreOptions {
+    readonly maxSenderKeys?: number;
+    readonly maxSenderDistributions?: number;
+}
+export declare class SenderKeyMemoryStore implements WaSenderKeyStoreContract {
+    private readonly senderKeys;
+    private readonly senderDistributions;
+    private readonly maxSenderKeys;
+    private readonly maxSenderDistributions;
+    constructor(options?: WaSenderKeyMemoryStoreOptions);
+    upsertSenderKey(record: SenderKeyRecord): Promise<void>;
+    upsertSenderKeyDistribution(record: SenderKeyDistributionRecord): Promise<void>;
+    upsertSenderKeyDistributions(records: readonly SenderKeyDistributionRecord[]): Promise<void>;
+    getGroupSenderKeyList(groupId: string): Promise<{
+        readonly skList: readonly SenderKeyRecord[];
+        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>;
+    clear(): Promise<void>;
+    private deleteMatching;
+    private makeKey;
+}

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

@@ -0,0 +1,51 @@
+import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../../signal/types';
+import type { WaSignalStore as WaSignalStoreContract } from '../../contracts/signal.store';
+export interface WaSignalMemoryStoreOptions {
+    readonly maxPreKeys?: number;
+    readonly maxSessions?: number;
+    readonly maxRemoteIdentities?: number;
+}
+export declare class WaSignalMemoryStore implements WaSignalStoreContract {
+    private registrationInfo;
+    private signedPreKey;
+    private signedPreKeyRotationTs;
+    private readonly preKeys;
+    private readonly uploadedPreKeys;
+    private serverHasPreKeys;
+    private readonly signalSessions;
+    private readonly remoteIdentities;
+    private nextPreKeyId;
+    private readonly maxPreKeys;
+    private readonly maxSessions;
+    private readonly maxRemoteIdentities;
+    constructor(options?: WaSignalMemoryStoreOptions);
+    getRegistrationInfo(): Promise<RegistrationInfo | null>;
+    setRegistrationInfo(info: RegistrationInfo): Promise<void>;
+    getSignedPreKey(): Promise<SignedPreKeyRecord | null>;
+    setSignedPreKey(record: SignedPreKeyRecord): Promise<void>;
+    getSignedPreKeyById(keyId: number): Promise<SignedPreKeyRecord | null>;
+    setSignedPreKeyRotationTs(value: number | null): Promise<void>;
+    getSignedPreKeyRotationTs(): Promise<number | null>;
+    putPreKey(record: PreKeyRecord): Promise<void>;
+    getOrGenPreKeys(count: number, generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<readonly PreKeyRecord[]>;
+    getPreKeyById(keyId: number): Promise<PreKeyRecord | null>;
+    getPreKeysById(keyIds: readonly number[]): Promise<readonly (PreKeyRecord | null)[]>;
+    consumePreKeyById(keyId: number): Promise<PreKeyRecord | null>;
+    getOrGenSinglePreKey(generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<PreKeyRecord>;
+    markKeyAsUploaded(keyId: number): Promise<void>;
+    setServerHasPreKeys(value: boolean): Promise<void>;
+    getServerHasPreKeys(): Promise<boolean>;
+    hasSession(address: SignalAddress): Promise<boolean>;
+    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
+    getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
+    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
+    deleteSession(address: SignalAddress): Promise<void>;
+    getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
+    setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
+    setRemoteIdentities(entries: readonly {
+        readonly address: SignalAddress;
+        readonly identityKey: Uint8Array;
+    }[]): Promise<void>;
+    clear(): Promise<void>;
+    private addUploadedPreKey;
+}

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

@@ -0,0 +1,14 @@
+import type { WaStoredThreadRecord, WaThreadStore as Contract } from '../../contracts/thread.store';
+export interface WaThreadMemoryStoreOptions {
+    readonly maxThreads?: number;
+}
+export declare class WaThreadMemoryStore implements Contract {
+    private readonly threads;
+    private readonly maxThreads;
+    constructor(options?: WaThreadMemoryStoreOptions);
+    upsert(record: WaStoredThreadRecord): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredThreadRecord | null>;
+    list(limit?: number): Promise<readonly WaStoredThreadRecord[]>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/sqlite/BaseSqliteStore.d.ts

@@ -0,0 +1,12 @@
+import { type WaSqliteConnection } from '../../providers/sqlite/connection';
+import { type WaSqliteMigrationDomain } from '../../providers/sqlite/migrations';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare abstract class BaseSqliteStore {
+    protected readonly options: WaSqliteStorageOptions;
+    private readonly migrationDomains;
+    private connectionPromise;
+    protected constructor(options: WaSqliteStorageOptions, migrationDomains: readonly WaSqliteMigrationDomain[]);
+    protected getConnection(): Promise<WaSqliteConnection>;
+    protected withTransaction<T>(run: (connection: WaSqliteConnection) => Promise<T> | T): Promise<T>;
+    destroy(): Promise<void>;
+}

package/dist/types/store/providers/sqlite/appstate.store.d.ts

@@ -0,0 +1,15 @@
+import type { AppStateCollectionName, WaAppStateSyncKey, WaAppStateStoreData } from '../../../appstate/types';
+import type { WaAppStateCollectionStateUpdate, WaAppStateCollectionStoreState, WaAppStateStore } from '../../contracts/appstate.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare class WaAppStateSqliteStore extends BaseSqliteStore implements WaAppStateStore {
+    constructor(options: WaSqliteStorageOptions);
+    exportData(): Promise<WaAppStateStoreData>;
+    upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
+    getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
+    getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
+    getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;
+    getCollectionState(collection: AppStateCollectionName): Promise<WaAppStateCollectionStoreState>;
+    setCollectionStates(updates: readonly WaAppStateCollectionStateUpdate[]): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/sqlite/auth.store.d.ts

@@ -0,0 +1,10 @@
+import type { WaAuthCredentials } from '../../../auth/types';
+import type { WaAuthStore } from '../../contracts/auth.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare class WaAuthSqliteStore extends BaseSqliteStore implements WaAuthStore {
+    constructor(options: WaSqliteStorageOptions);
+    load(): Promise<WaAuthCredentials | null>;
+    save(credentials: WaAuthCredentials): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/sqlite/connection.d.ts

@@ -0,0 +1,10 @@
+import type { WaSqliteDriver, WaSqliteStorageOptions } from '../../types';
+export interface WaSqliteConnection {
+    readonly driver: Exclude<WaSqliteDriver, 'auto'>;
+    exec(sql: string): void;
+    run(sql: string, params?: readonly unknown[]): void;
+    get<T extends Record<string, unknown>>(sql: string, params?: readonly unknown[]): T | null;
+    all<T extends Record<string, unknown>>(sql: string, params?: readonly unknown[]): readonly T[];
+    close(): void;
+}
+export declare function openSqliteConnection(options: WaSqliteStorageOptions): Promise<WaSqliteConnection>;

package/dist/types/store/providers/sqlite/contact.store.d.ts

@@ -0,0 +1,10 @@
+import type { WaContactStore as Contract, WaStoredContactRecord } from '../../contracts/contact.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare class WaContactSqliteStore extends BaseSqliteStore implements Contract {
+    constructor(options: WaSqliteStorageOptions);
+    upsert(record: WaStoredContactRecord): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredContactRecord | null>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/sqlite/device-list.store.d.ts

@@ -0,0 +1,18 @@
+import type { WaDeviceListSnapshot, WaDeviceListStore } from '../../contracts/device-list.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare class WaDeviceListSqliteStore extends BaseSqliteStore implements WaDeviceListStore {
+    private readonly ttlMs;
+    private readonly batchSize;
+    constructor(options: WaSqliteStorageOptions, ttlMs?: number, batchSize?: number);
+    getTtlMs(): number;
+    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>;
+    clear(): Promise<void>;
+    private upsertUserDevicesRow;
+    private deleteUserDevicesByJids;
+}

package/dist/types/store/providers/sqlite/message.store.d.ts

@@ -0,0 +1,11 @@
+import type { WaMessageStore as Contract, WaStoredMessageRecord } from '../../contracts/message.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare class WaMessageSqliteStore extends BaseSqliteStore implements Contract {
+    constructor(options: WaSqliteStorageOptions);
+    upsert(record: WaStoredMessageRecord): Promise<void>;
+    getById(id: string): Promise<WaStoredMessageRecord | null>;
+    listByThread(threadJid: string, limit?: number, beforeTimestampMs?: number): Promise<readonly WaStoredMessageRecord[]>;
+    deleteById(id: string): Promise<number>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/sqlite/migrations.d.ts

@@ -0,0 +1,3 @@
+import type { WaSqliteConnection } from '../../providers/sqlite/connection';
+export type WaSqliteMigrationDomain = 'auth' | 'signal' | 'senderKey' | 'appState' | 'retry' | 'participants' | 'deviceList' | 'mailbox';
+export declare function ensureSqliteMigrations(db: WaSqliteConnection, domains: readonly WaSqliteMigrationDomain[]): Promise<void>;

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

@@ -0,0 +1,13 @@
+import type { WaParticipantsSnapshot, WaParticipantsStore } from '../../contracts/participants.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare class WaParticipantsSqliteStore extends BaseSqliteStore implements WaParticipantsStore {
+    private readonly ttlMs;
+    constructor(options: WaSqliteStorageOptions, ttlMs?: number);
+    getTtlMs(): number;
+    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/providers/sqlite/retry.store.d.ts

@@ -0,0 +1,16 @@
+import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../../retry/types';
+import type { WaRetryStore } from '../../contracts/retry.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare class WaRetrySqliteStore extends BaseSqliteStore implements WaRetryStore {
+    private readonly ttlMs;
+    constructor(options: WaSqliteStorageOptions, ttlMs?: number);
+    getTtlMs(): number;
+    upsertOutboundMessage(record: WaRetryOutboundMessageRecord): Promise<void>;
+    getOutboundMessage(messageId: string): Promise<WaRetryOutboundMessageRecord | null>;
+    updateOutboundMessageState(messageId: string, state: WaRetryOutboundState, updatedAtMs: number, expiresAtMs: number): Promise<void>;
+    incrementInboundCounter(messageId: string, requesterJid: string, updatedAtMs: number, expiresAtMs: number): Promise<number>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+    private countRows;
+}

package/dist/types/store/providers/sqlite/sender-key.store.d.ts

@@ -0,0 +1,25 @@
+import type { SenderKeyDistributionRecord, SenderKeyRecord, SignalAddress } from '../../../signal/types';
+import type { WaSenderKeyStore as WaSenderKeyStoreContract } from '../../contracts/sender-key.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare class SenderKeySqliteStore extends BaseSqliteStore implements WaSenderKeyStoreContract {
+    private readonly distributionBatchSize;
+    constructor(options: WaSqliteStorageOptions, distributionBatchSize?: number);
+    upsertSenderKey(record: SenderKeyRecord): Promise<void>;
+    upsertSenderKeyDistribution(record: SenderKeyDistributionRecord): Promise<void>;
+    upsertSenderKeyDistributions(records: readonly SenderKeyDistributionRecord[]): Promise<void>;
+    getGroupSenderKeyList(groupId: string): Promise<{
+        readonly skList: readonly SenderKeyRecord[];
+        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>;
+    clear(): Promise<void>;
+    private countDelete;
+    private upsertSenderKeyDistributionRow;
+    private distributionRowKey;
+    private distributionTargetKey;
+}

package/dist/types/store/providers/sqlite/signal.store.d.ts

@@ -0,0 +1,46 @@
+import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../../signal/types';
+import type { WaSignalStore as WaSignalStoreContract } from '../../contracts/signal.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+interface WaSignalSqliteStoreOptions {
+    readonly preKeyBatchSize?: number;
+    readonly hasSessionBatchSize?: number;
+}
+export declare class WaSignalSqliteStore extends BaseSqliteStore implements WaSignalStoreContract {
+    private readonly preKeyBatchSize;
+    private readonly hasSessionBatchSize;
+    constructor(options: WaSqliteStorageOptions, storeOptions?: WaSignalSqliteStoreOptions);
+    getRegistrationInfo(): Promise<RegistrationInfo | null>;
+    setRegistrationInfo(info: RegistrationInfo): Promise<void>;
+    getSignedPreKey(): Promise<SignedPreKeyRecord | null>;
+    setSignedPreKey(record: SignedPreKeyRecord): Promise<void>;
+    getSignedPreKeyById(keyId: number): Promise<SignedPreKeyRecord | null>;
+    setSignedPreKeyRotationTs(value: number | null): Promise<void>;
+    getSignedPreKeyRotationTs(): Promise<number | null>;
+    putPreKey(record: PreKeyRecord): Promise<void>;
+    getOrGenPreKeys(count: number, generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<readonly PreKeyRecord[]>;
+    getPreKeyById(keyId: number): Promise<PreKeyRecord | null>;
+    getPreKeysById(keyIds: readonly number[]): Promise<readonly (PreKeyRecord | null)[]>;
+    consumePreKeyById(keyId: number): Promise<PreKeyRecord | null>;
+    getOrGenSinglePreKey(generator: (keyId: number) => PreKeyRecord | Promise<PreKeyRecord>): Promise<PreKeyRecord>;
+    markKeyAsUploaded(keyId: number): Promise<void>;
+    setServerHasPreKeys(value: boolean): Promise<void>;
+    getServerHasPreKeys(): Promise<boolean>;
+    hasSession(address: SignalAddress): Promise<boolean>;
+    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
+    getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
+    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
+    deleteSession(address: SignalAddress): Promise<void>;
+    getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
+    setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
+    setRemoteIdentities(entries: readonly {
+        readonly address: SignalAddress;
+        readonly identityKey: Uint8Array;
+    }[]): Promise<void>;
+    clear(): Promise<void>;
+    private upsertPreKey;
+    private ensureMetaRow;
+    private getMeta;
+    private upsertRemoteIdentity;
+}
+export {};

package/dist/types/store/providers/sqlite/thread.store.d.ts

@@ -0,0 +1,11 @@
+import type { WaStoredThreadRecord, WaThreadStore as Contract } from '../../contracts/thread.store';
+import { BaseSqliteStore } from '../../providers/sqlite/BaseSqliteStore';
+import type { WaSqliteStorageOptions } from '../../types';
+export declare class WaThreadSqliteStore extends BaseSqliteStore implements Contract {
+    constructor(options: WaSqliteStorageOptions);
+    upsert(record: WaStoredThreadRecord): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredThreadRecord | null>;
+    list(limit?: number): Promise<readonly WaStoredThreadRecord[]>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,103 @@
+import type { WaAppStateStore } from './contracts/appstate.store';
+import type { WaAuthStore } from './contracts/auth.store';
+import type { WaContactStore } from './contracts/contact.store';
+import type { WaDeviceListStore } from './contracts/device-list.store';
+import type { WaMessageStore } from './contracts/message.store';
+import type { WaParticipantsStore } from './contracts/participants.store';
+import type { WaRetryStore } from './contracts/retry.store';
+import type { WaSenderKeyStore } from './contracts/sender-key.store';
+import type { WaSignalStore } from './contracts/signal.store';
+import type { WaThreadStore } from './contracts/thread.store';
+export type WaSqliteDriver = 'auto' | 'better-sqlite3' | 'bun';
+export interface WaSqliteStorageOptions {
+    readonly path: string;
+    readonly sessionId: string;
+    readonly driver?: WaSqliteDriver;
+    readonly pragmas?: Readonly<Record<string, string | number>>;
+}
+export interface WaStoreSession {
+    readonly auth: WaAuthStore;
+    readonly signal: WaSignalStore;
+    readonly senderKey: WaSenderKeyStore;
+    readonly appState: WaAppStateStore;
+    readonly retry: WaRetryStore;
+    readonly participants: WaParticipantsStore;
+    readonly deviceList: WaDeviceListStore;
+    readonly messages: WaMessageStore;
+    readonly threads: WaThreadStore;
+    readonly contacts: WaContactStore;
+    destroyCaches(): Promise<void>;
+    destroy(): Promise<void>;
+}
+export interface WaStore {
+    session(sessionId: string): WaStoreSession;
+    destroyCaches(): Promise<void>;
+    destroy(): Promise<void>;
+}
+export interface WaStoreProviderSelection {
+    readonly auth?: 'sqlite';
+    readonly signal?: 'sqlite' | 'memory';
+    readonly senderKey?: 'sqlite' | 'memory';
+    readonly appState?: 'sqlite' | 'memory';
+    readonly messages?: 'none' | 'sqlite' | 'memory';
+    readonly threads?: 'none' | 'sqlite' | 'memory';
+    readonly contacts?: 'none' | 'sqlite' | 'memory';
+}
+export interface WaStoreCacheProviderSelection {
+    readonly retry?: 'sqlite' | 'memory';
+    readonly participants?: 'none' | 'sqlite' | 'memory';
+    readonly deviceList?: 'none' | 'sqlite' | 'memory';
+}
+export interface WaStoreCacheTtlSelection {
+    readonly retryMs?: number;
+    readonly participantsMs?: number;
+    readonly deviceListMs?: number;
+}
+export interface WaStoreSqliteBatchSizeSelection {
+    readonly deviceList?: number;
+    readonly senderKeyDistribution?: number;
+    readonly signalPreKey?: number;
+    readonly signalHasSession?: number;
+}
+export interface WaStoreMemoryLimitSelection {
+    readonly appStateSyncKeys?: number;
+    readonly appStateCollectionEntries?: number;
+    readonly signalPreKeys?: number;
+    readonly signalSessions?: number;
+    readonly signalRemoteIdentities?: number;
+    readonly senderKeys?: number;
+    readonly senderDistributions?: number;
+    readonly participantsGroups?: number;
+    readonly deviceListUsers?: number;
+    readonly messages?: number;
+    readonly threads?: number;
+    readonly contacts?: number;
+}
+export type WaStoreDomainValueOrFactory<T> = T | ((sessionId: string) => T);
+export interface WaCreateStoreCustomProviders {
+    readonly auth?: WaStoreDomainValueOrFactory<WaAuthStore>;
+    readonly signal?: WaStoreDomainValueOrFactory<WaSignalStore>;
+    readonly senderKey?: WaStoreDomainValueOrFactory<WaSenderKeyStore>;
+    readonly appState?: WaStoreDomainValueOrFactory<WaAppStateStore>;
+    readonly messages?: WaStoreDomainValueOrFactory<WaMessageStore>;
+    readonly threads?: WaStoreDomainValueOrFactory<WaThreadStore>;
+    readonly contacts?: WaStoreDomainValueOrFactory<WaContactStore>;
+}
+export interface WaCreateStoreCustomCacheProviders {
+    readonly retry?: WaStoreDomainValueOrFactory<WaRetryStore>;
+    readonly participants?: WaStoreDomainValueOrFactory<WaParticipantsStore>;
+    readonly deviceList?: WaStoreDomainValueOrFactory<WaDeviceListStore>;
+}
+export interface WaCreateStoreOptions {
+    readonly sqlite?: Omit<WaSqliteStorageOptions, 'sessionId'> & {
+        readonly batchSizes?: WaStoreSqliteBatchSizeSelection;
+    };
+    readonly memory?: {
+        readonly limits?: WaStoreMemoryLimitSelection;
+    };
+    readonly providers?: WaStoreProviderSelection;
+    readonly cacheProviders?: WaStoreCacheProviderSelection;
+    readonly cacheTtlMs?: WaStoreCacheTtlSelection;
+    readonly custom?: WaCreateStoreCustomProviders;
+    readonly customCache?: WaCreateStoreCustomCacheProviders;
+}

package/dist/types/transport/WaComms.d.ts

@@ -0,0 +1,61 @@
+import type { Logger } from '../infra/log/types';
+import type { WaCommsConfig, WaCommsState } from './types';
+type StanzaHandler = (payload: Uint8Array) => void | Promise<void>;
+type InflateFrame = (compressed: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+export declare class WaComms {
+    private readonly config;
+    private readonly logger;
+    private readonly socket;
+    private started;
+    private connected;
+    private handlingRequests;
+    private preventRetry;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private waiters;
+    private stanzaHandler;
+    private inflateFrame;
+    private pendingFrames;
+    private pendingFramesByteLength;
+    private readonly pendingFramesMaxCount;
+    private readonly pendingFramesMaxBytes;
+    private pendingFramesOverflowClosing;
+    private resumeInFlight;
+    private resumeHandshakeFailures;
+    private usedResumeHandshake;
+    private noiseSession;
+    private lastServerStaticKey;
+    private frameProcessingQueue;
+    private readonly frameHandlerQueue;
+    constructor(config: WaCommsConfig, logger?: Logger);
+    private applyRoutingInfoToSocketConfig;
+    startComms(handleStanza: StanzaHandler, inflateFrame?: InflateFrame): void;
+    waitForConnection(timeoutMs?: number): Promise<void>;
+    startHandlingRequests(): void;
+    stopComms(): Promise<void>;
+    closeSocketAndResume(): Promise<void>;
+    closeSocketAndPreventRetry(): Promise<void>;
+    sendFrame(payload: Uint8Array): Promise<void>;
+    getCommsState(): Readonly<WaCommsState>;
+    getServerStaticKey(): Uint8Array | null;
+    private openSocket;
+    private onSocketClosed;
+    private onSocketMessage;
+    private processSocketPayload;
+    private onDecodedFrame;
+    private onSocketOpened;
+    private flushPendingFrames;
+    private routeDecodedFrames;
+    private clearPendingFrames;
+    private tryQueuePendingFrames;
+    private schedulePendingFramesOverflowClose;
+    private scheduleDecodedFrame;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+    private removeWaiter;
+    private withStickyRoutingCookie;
+    private buildNoiseConfigForAttempt;
+    private resetConnectionState;
+    private drainWaiters;
+}
+export {};

package/dist/types/transport/WaWebSocket.d.ts

@@ -0,0 +1,36 @@
+import type { Logger } from '../infra/log/types';
+import type { SocketCloseInfo, SocketOpenInfo, WaSocketConfig, WaSocketHandlers } from './types';
+export declare class WaWebSocket {
+    private readonly config;
+    private readonly socketUrls;
+    private readonly logger;
+    private readonly webSocketCtor;
+    private readonly socketRuntime;
+    private readonly connectingSockets;
+    private handlers;
+    private socket;
+    private closeWaiter;
+    constructor(config: WaSocketConfig, logger?: Logger);
+    setHandlers(handlers: WaSocketHandlers): void;
+    isOpen(): boolean;
+    isConnecting(): boolean;
+    getReadyState(): number;
+    open(): Promise<SocketOpenInfo>;
+    close(code?: number, reason?: string): Promise<SocketCloseInfo | null>;
+    send(data: string | ArrayBuffer | Uint8Array): Promise<void>;
+    private openSingle;
+    private openConcurrently;
+    private bindRuntimeHandlers;
+    private handleMessage;
+    private normalizePayload;
+    private createPendingSocket;
+    private bindPendingSocket;
+    private settlePendingSocket;
+    private releasePendingSocket;
+    private activatePendingSocket;
+    private toCloseInfo;
+    private handleRuntimeError;
+    private handleRuntimeClose;
+    private closeSocketSafe;
+    private createRawSocket;
+}