zapo-js 0.1.2 → 0.3.0

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

@@ -0,0 +1,16 @@
+export interface WaMessageSecretEntry {
+    readonly secret: Uint8Array;
+    readonly senderJid: string;
+}
+export interface WaMessageSecretStore {
+    get(messageId: string, nowMs?: number): Promise<WaMessageSecretEntry | null>;
+    getBatch(messageIds: readonly string[], nowMs?: number): Promise<readonly (WaMessageSecretEntry | null)[]>;
+    set(messageId: string, entry: WaMessageSecretEntry): Promise<void>;
+    setBatch(entries: readonly {
+        readonly messageId: string;
+        readonly entry: WaMessageSecretEntry;
+    }[]): Promise<void>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+    destroy?(): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import type { PreKeyRecord } from '../../signal/types';
+export interface WaPreKeyStore {
+    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>;
+    clear(): Promise<void>;
+}

package/dist/types/store/contracts/privacy-token.store.d.ts

@@ -0,0 +1,16 @@
+export interface WaStoredPrivacyTokenRecord {
+    readonly jid: string;
+    readonly tcToken?: Uint8Array;
+    readonly tcTokenTimestamp?: number;
+    readonly tcTokenSenderTimestamp?: number;
+    readonly nctSalt?: Uint8Array;
+    readonly updatedAtMs: number;
+}
+export interface WaPrivacyTokenStore {
+    upsert(record: WaStoredPrivacyTokenRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredPrivacyTokenRecord[]): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredPrivacyTokenRecord | null>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+    destroy?(): Promise<void>;
+}

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

@@ -1,10 +1,17 @@
 import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../retry/types';
 export interface WaRetryStore {
+    getOutboundRequesterStatus(messageId: string, requesterDeviceJid: string): Promise<{
+        readonly eligible: boolean;
+        readonly delivered: boolean;
+    } | null>;
     getTtlMs?(): number;
+    supportsRawReplayPayload?(): boolean;
     destroy?(): Promise<void>;
     upsertOutboundMessage(record: WaRetryOutboundMessageRecord): Promise<void>;
+    deleteOutboundMessage(messageId: string): Promise<number>;
     getOutboundMessage(messageId: string): Promise<WaRetryOutboundMessageRecord | null>;
     updateOutboundMessageState(messageId: string, state: WaRetryOutboundState, updatedAtMs: number, expiresAtMs: number): Promise<void>;
+    markOutboundRequesterDelivered(messageId: string, requesterDeviceJid: string, 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>;

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

@@ -0,0 +1,14 @@
+import type { SignalAddress, SignalSessionRecord } from '../../signal/types';
+export interface WaSessionStore {
+    hasSession(address: SignalAddress): Promise<boolean>;
+    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
+    getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
+    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
+    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
+    setSessionsBatch(entries: readonly {
+        readonly address: SignalAddress;
+        readonly session: SignalSessionRecord;
+    }[]): Promise<void>;
+    deleteSession(address: SignalAddress): Promise<void>;
+    clear(): Promise<void>;
+}

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

@@ -1,4 +1,4 @@
-import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../signal/types';
+import type { RegistrationInfo, SignedPreKeyRecord } from '../../signal/types';
 export interface WaSignalStore {
     getRegistrationInfo(): Promise<RegistrationInfo | null>;
     setRegistrationInfo(info: RegistrationInfo): Promise<void>;
@@ -7,31 +7,5 @@ export interface WaSignalStore {
     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>;
-    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
-    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
-    setSessionsBatch(entries: readonly {
-        readonly address: SignalAddress;
-        readonly session: SignalSessionRecord;
-    }[]): Promise<void>;
-    deleteSession(address: SignalAddress): Promise<void>;
-    getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
-    getRemoteIdentities(addresses: readonly SignalAddress[]): Promise<readonly (Uint8Array | null)[]>;
-    setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
-    setRemoteIdentities(entries: readonly {
-        readonly address: SignalAddress;
-        readonly identityKey: Uint8Array;
-    }[]): Promise<void>;
     clear(): Promise<void>;
 }

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

@@ -1,2 +1,2 @@
 import type { WaCreateStoreOptions, WaStore } from './types';
-export declare function createStore(options: WaCreateStoreOptions): WaStore;
+export declare function createStore<B extends string>(options: WaCreateStoreOptions<B>): WaStore;

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

@@ -1,31 +1,31 @@
-export type { WaCreateStoreCustomCacheProviders, WaCreateStoreCustomProviders, WaCreateStoreOptions, WaSqliteDriver, WaSqliteTableName, WaSqliteTableNameOverrides, WaSqliteStorageOptions, WaStoreSqliteBatchSizeSelection, WaStoreMemoryLimitSelection, WaStoreCacheProviderSelection, WaStoreCacheTtlSelection, WaStore, WaStoreDomainValueOrFactory, WaStoreProviderSelection, WaStoreSession } from './types';
-export { WaAuthSqliteStore } from './providers/sqlite/auth.store';
-export { WaAppStateSqliteStore } from './providers/sqlite/appstate.store';
+export type { WaCreateStoreOptions, WaStore, WaStoreBackend, WaCacheDomain, WaStoreDomain, WaStoreMemoryLimitSelection, WaStoreSession } from './types';
 export { createStore } from './createStore';
 export type { WaAuthStore } from './contracts/auth.store';
 export type { WaContactStore, WaStoredContactRecord } from './contracts/contact.store';
 export type { WaDeviceListSnapshot, WaDeviceListStore } from './contracts/device-list.store';
+export type { WaMessageSecretEntry, WaMessageSecretStore } from './contracts/message-secret.store';
 export type { WaMessageStore, WaStoredMessageRecord } from './contracts/message.store';
 export type { WaParticipantsSnapshot, WaParticipantsStore } from './contracts/participants.store';
-export type { WaAppStateCollectionStoreState, WaAppStateStore } from './contracts/appstate.store';
+export type { WaAppStateCollectionStateUpdate, WaAppStateCollectionStoreState, WaAppStateStore } from './contracts/appstate.store';
+export type { WaIdentityStore } from './contracts/identity.store';
+export type { WaPreKeyStore } from './contracts/pre-key.store';
 export type { WaSenderKeyStore } from './contracts/sender-key.store';
+export type { WaSessionStore } from './contracts/session.store';
 export type { WaSignalStore } from './contracts/signal.store';
 export type { WaRetryStore } from './contracts/retry.store';
 export type { WaStoredThreadRecord, WaThreadStore } from './contracts/thread.store';
-export { WaSignalSqliteStore } from './providers/sqlite/signal.store';
-export { SenderKeySqliteStore } from './providers/sqlite/sender-key.store';
-export { WaRetrySqliteStore } from './providers/sqlite/retry.store';
-export { WaParticipantsSqliteStore } from './providers/sqlite/participants.store';
-export { WaDeviceListSqliteStore } from './providers/sqlite/device-list.store';
+export type { WaPrivacyTokenStore, WaStoredPrivacyTokenRecord } from './contracts/privacy-token.store';
 export { WaAppStateMemoryStore } from './providers/memory/appstate.store';
 export { WaSignalMemoryStore } from './providers/memory/signal.store';
+export { WaPreKeyMemoryStore } from './providers/memory/pre-key.store';
+export { WaSessionMemoryStore } from './providers/memory/session.store';
+export { WaIdentityMemoryStore } from './providers/memory/identity.store';
 export { SenderKeyMemoryStore } from './providers/memory/sender-key.store';
 export { WaRetryMemoryStore } from './providers/memory/retry.store';
 export { WaParticipantsMemoryStore } from './providers/memory/participants.store';
 export { WaDeviceListMemoryStore } from './providers/memory/device-list.store';
 export { WaContactMemoryStore } from './providers/memory/contact.store';
+export { WaMessageSecretMemoryStore } from './providers/memory/message-secret.store';
 export { WaMessageMemoryStore } from './providers/memory/message.store';
 export { WaThreadMemoryStore } from './providers/memory/thread.store';
-export { WaContactSqliteStore } from './providers/sqlite/contact.store';
-export { WaMessageSqliteStore } from './providers/sqlite/message.store';
-export { WaThreadSqliteStore } from './providers/sqlite/thread.store';
+export { WaPrivacyTokenMemoryStore } from './providers/memory/privacy-token.store';

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

@@ -0,0 +1,3 @@
+import type { WaAppStateStore } from '../contracts/appstate.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withAppStateLock(store: WaAppStateStore): WithDestroyLifecycle<WaAppStateStore>;

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

@@ -0,0 +1,3 @@
+import type { WaAuthStore } from '../contracts/auth.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withAuthLock(store: WaAuthStore): WithDestroyLifecycle<WaAuthStore>;

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

@@ -0,0 +1,3 @@
+import type { WaContactStore } from '../contracts/contact.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withContactLock(store: WaContactStore): WithDestroyLifecycle<WaContactStore>;

package/dist/types/store/locks/device-list.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaDeviceListStore } from '../contracts/device-list.store';
+export declare function withDeviceListLock(store: WaDeviceListStore): WaDeviceListStore;

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

@@ -0,0 +1,3 @@
+import type { WaIdentityStore } from '../contracts/identity.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withIdentityLock(store: WaIdentityStore): WithDestroyLifecycle<WaIdentityStore>;

package/dist/types/store/locks/message-secret.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaMessageSecretStore } from '../contracts/message-secret.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withMessageSecretLock(store: WaMessageSecretStore): WithDestroyLifecycle<WaMessageSecretStore>;

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

@@ -0,0 +1,3 @@
+import type { WaMessageStore } from '../contracts/message.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withMessageLock(store: WaMessageStore): WithDestroyLifecycle<WaMessageStore>;

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

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

package/dist/types/store/locks/pre-key.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaPreKeyStore } from '../contracts/pre-key.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withPreKeyLock(store: WaPreKeyStore): WithDestroyLifecycle<WaPreKeyStore>;

package/dist/types/store/locks/privacy-token.lock.d.ts

@@ -0,0 +1,2 @@
+import type { WaPrivacyTokenStore } from '../contracts/privacy-token.store';
+export declare function withPrivacyTokenLock(store: WaPrivacyTokenStore): WaPrivacyTokenStore;

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

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

package/dist/types/store/locks/sender-key.lock.d.ts

@@ -0,0 +1,3 @@
+import type { WaSenderKeyStore } from '../contracts/sender-key.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withSenderKeyLock(store: WaSenderKeyStore): WithDestroyLifecycle<WaSenderKeyStore>;

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

@@ -0,0 +1,3 @@
+import type { WaSessionStore } from '../contracts/session.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withSessionLock(store: WaSessionStore): WithDestroyLifecycle<WaSessionStore>;

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

@@ -0,0 +1,3 @@
+import type { WaSignalStore } from '../contracts/signal.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withSignalLock(store: WaSignalStore): WithDestroyLifecycle<WaSignalStore>;

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

@@ -0,0 +1,3 @@
+import type { WaThreadStore } from '../contracts/thread.store';
+import type { WithDestroyLifecycle } from '../types';
+export declare function withThreadLock(store: WaThreadStore): WithDestroyLifecycle<WaThreadStore>;

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

@@ -1,10 +1,14 @@
 import type { WaContactStore } from './contracts/contact.store';
 import type { WaDeviceListStore } from './contracts/device-list.store';
+import type { WaMessageSecretStore } from './contracts/message-secret.store';
 import type { WaMessageStore } from './contracts/message.store';
 import type { WaParticipantsStore } from './contracts/participants.store';
+import type { WaRetryStore } from './contracts/retry.store';
 import type { WaThreadStore } from './contracts/thread.store';
+export declare const NOOP_MESSAGE_SECRET_STORE: WaMessageSecretStore;
 export declare const NOOP_MESSAGE_STORE: WaMessageStore;
 export declare const NOOP_THREAD_STORE: WaThreadStore;
 export declare const NOOP_CONTACT_STORE: WaContactStore;
+export declare const NOOP_RETRY_STORE: WaRetryStore;
 export declare const NOOP_PARTICIPANTS_STORE: WaParticipantsStore;
 export declare const NOOP_DEVICE_LIST_STORE: WaDeviceListStore;

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

@@ -12,7 +12,7 @@ export declare class WaAppStateMemoryStore implements WaAppStateStore {
     constructor(initial?: WaAppStateStoreData, options?: WaAppStateMemoryStoreOptions);
     exportData(): Promise<WaAppStateStoreData>;
     upsertSyncKeys(keys: readonly WaAppStateSyncKey[]): Promise<number>;
-    getSyncKey(keyId: Uint8Array): Promise<WaAppStateSyncKey | null>;
+    getSyncKeysBatch(keyIds: readonly Uint8Array[]): Promise<readonly (WaAppStateSyncKey | null)[]>;
     getSyncKeyData(keyId: Uint8Array): Promise<Uint8Array | null>;
     getSyncKeyDataBatch(keyIds: readonly Uint8Array[]): Promise<readonly (Uint8Array | null)[]>;
     getActiveSyncKey(): Promise<WaAppStateSyncKey | null>;

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

@@ -0,0 +1,18 @@
+import type { SignalAddress } from '../../../signal/types';
+import type { WaIdentityStore as WaIdentityStoreContract } from '../../contracts/identity.store';
+export interface WaIdentityMemoryStoreOptions {
+    readonly maxRemoteIdentities?: number;
+}
+export declare class WaIdentityMemoryStore implements WaIdentityStoreContract {
+    private readonly remoteIdentities;
+    private readonly maxRemoteIdentities;
+    constructor(options?: WaIdentityMemoryStoreOptions);
+    getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
+    getRemoteIdentities(addresses: readonly SignalAddress[]): Promise<readonly (Uint8Array | null)[]>;
+    setRemoteIdentity(address: SignalAddress, identityKey: Uint8Array): Promise<void>;
+    setRemoteIdentities(entries: readonly {
+        readonly address: SignalAddress;
+        readonly identityKey: Uint8Array;
+    }[]): Promise<void>;
+    clear(): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import type { WaMessageSecretEntry, WaMessageSecretStore } from '../../contracts/message-secret.store';
+export interface WaMessageSecretMemoryStoreOptions {
+    readonly maxSecrets?: number;
+}
+export declare class WaMessageSecretMemoryStore implements WaMessageSecretStore {
+    private readonly secrets;
+    private readonly ttlMs;
+    private readonly maxSecrets;
+    private readonly cleanupTimer;
+    constructor(ttlMs?: number, options?: WaMessageSecretMemoryStoreOptions);
+    get(messageId: string, nowMs?: number): Promise<WaMessageSecretEntry | null>;
+    getBatch(messageIds: readonly string[], nowMs?: number): Promise<readonly (WaMessageSecretEntry | null)[]>;
+    set(messageId: string, entry: WaMessageSecretEntry): Promise<void>;
+    setBatch(entries: readonly {
+        readonly messageId: string;
+        readonly entry: WaMessageSecretEntry;
+    }[]): Promise<void>;
+    cleanupExpired(nowMs: number): Promise<number>;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+}

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

@@ -0,0 +1,23 @@
+import type { PreKeyRecord } from '../../../signal/types';
+import type { WaPreKeyStore as WaPreKeyStoreContract } from '../../contracts/pre-key.store';
+export interface WaPreKeyMemoryStoreOptions {
+    readonly maxPreKeys?: number;
+}
+export declare class WaPreKeyMemoryStore implements WaPreKeyStoreContract {
+    private readonly preKeys;
+    private readonly uploadedPreKeys;
+    private serverHasPreKeys;
+    private nextPreKeyId;
+    private readonly maxPreKeys;
+    constructor(options?: WaPreKeyMemoryStoreOptions);
+    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>;
+    clear(): Promise<void>;
+}

package/dist/types/store/providers/memory/privacy-token.store.d.ts

@@ -0,0 +1,13 @@
+import type { WaPrivacyTokenStore, WaStoredPrivacyTokenRecord } from '../../contracts/privacy-token.store';
+export declare class WaPrivacyTokenMemoryStore implements WaPrivacyTokenStore {
+    private readonly records;
+    private readonly maxEntries;
+    constructor(maxEntries?: number);
+    upsert(record: WaStoredPrivacyTokenRecord): Promise<void>;
+    upsertBatch(records: readonly WaStoredPrivacyTokenRecord[]): Promise<void>;
+    getByJid(jid: string): Promise<WaStoredPrivacyTokenRecord | null>;
+    deleteByJid(jid: string): Promise<number>;
+    clear(): Promise<void>;
+    destroy(): Promise<void>;
+    private mergeRecord;
+}

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

@@ -1,15 +1,29 @@
 import type { WaRetryOutboundMessageRecord, WaRetryOutboundState } from '../../../retry/types';
 import type { WaRetryStore } from '../../contracts/retry.store';
+export interface WaRetryMemoryStoreOptions {
+    readonly maxOutboundMessages?: number;
+    readonly maxInboundCounters?: number;
+}
 export declare class WaRetryMemoryStore implements WaRetryStore {
     private readonly outboundMessages;
+    private readonly eligibleSets;
     private readonly inboundCounters;
     private readonly ttlMs;
+    private readonly maxOutboundMessages;
+    private readonly maxInboundCounters;
     private readonly cleanupTimer;
-    constructor(ttlMs?: number);
+    constructor(ttlMs?: number, options?: WaRetryMemoryStoreOptions);
     getTtlMs(): number;
+    supportsRawReplayPayload(): boolean;
+    getOutboundRequesterStatus(messageId: string, requesterDeviceJid: string): Promise<{
+        readonly eligible: boolean;
+        readonly delivered: boolean;
+    } | null>;
     upsertOutboundMessage(record: WaRetryOutboundMessageRecord): Promise<void>;
+    deleteOutboundMessage(messageId: string): Promise<number>;
     getOutboundMessage(messageId: string): Promise<WaRetryOutboundMessageRecord | null>;
     updateOutboundMessageState(messageId: string, state: WaRetryOutboundState, updatedAtMs: number, expiresAtMs: number): Promise<void>;
+    markOutboundRequesterDelivered(messageId: string, requesterDeviceJid: string, 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>;

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

@@ -0,0 +1,21 @@
+import type { SignalAddress, SignalSessionRecord } from '../../../signal/types';
+import type { WaSessionStore as WaSessionStoreContract } from '../../contracts/session.store';
+export interface WaSessionMemoryStoreOptions {
+    readonly maxSessions?: number;
+}
+export declare class WaSessionMemoryStore implements WaSessionStoreContract {
+    private readonly signalSessions;
+    private readonly maxSessions;
+    constructor(options?: WaSessionMemoryStoreOptions);
+    hasSession(address: SignalAddress): Promise<boolean>;
+    hasSessions(addresses: readonly SignalAddress[]): Promise<readonly boolean[]>;
+    getSession(address: SignalAddress): Promise<SignalSessionRecord | null>;
+    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
+    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
+    setSessionsBatch(entries: readonly {
+        readonly address: SignalAddress;
+        readonly session: SignalSessionRecord;
+    }[]): Promise<void>;
+    deleteSession(address: SignalAddress): Promise<void>;
+    clear(): Promise<void>;
+}

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

@@ -1,24 +1,10 @@
-import type { PreKeyRecord, RegistrationInfo, SignalAddress, SignalSessionRecord, SignedPreKeyRecord } from '../../../signal/types';
+import type { RegistrationInfo, 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);
+    constructor();
     getRegistrationInfo(): Promise<RegistrationInfo | null>;
     setRegistrationInfo(info: RegistrationInfo): Promise<void>;
     getSignedPreKey(): Promise<SignedPreKeyRecord | null>;
@@ -26,32 +12,5 @@ export declare class WaSignalMemoryStore implements WaSignalStoreContract {
     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>;
-    getSessionsBatch(addresses: readonly SignalAddress[]): Promise<readonly (SignalSessionRecord | null)[]>;
-    setSession(address: SignalAddress, session: SignalSessionRecord): Promise<void>;
-    setSessionsBatch(entries: readonly {
-        readonly address: SignalAddress;
-        readonly session: SignalSessionRecord;
-    }[]): Promise<void>;
-    deleteSession(address: SignalAddress): Promise<void>;
-    getRemoteIdentity(address: SignalAddress): Promise<Uint8Array | null>;
-    getRemoteIdentities(addresses: readonly SignalAddress[]): Promise<readonly (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

@@ -1,4 +1,4 @@
-import type { WaStoredThreadRecord, WaThreadStore as Contract } from '../../contracts/thread.store';
+import type { WaThreadStore as Contract, WaStoredThreadRecord } from '../../contracts/thread.store';
 export interface WaThreadMemoryStoreOptions {
     readonly maxThreads?: number;
 }