@signalapp/mock-server/src/api/storage-state.d.ts

Mock Signal Server for writing tests

import { Buffer } from 'node:buffer';
import { signalservice as Proto } from '../../protos/compiled';
import { Device } from '../data/device';
import { ServiceIdKind } from '../types';
import { Group } from './group';
import { PrimaryDevice } from './primary-device';
type RecordValue = NonNullable<Proto.StorageRecord.Params['record']>;
export type StorageStateRecord<Value extends RecordValue = RecordValue> = Readonly<{
    type: Proto.ManifestRecord.Identifier.Type;
    key: Buffer<ArrayBuffer>;
    record: Value;
}>;
export type StorageStateNewRecord = Readonly<{
    type: Proto.ManifestRecord.Identifier.Type;
    key?: Buffer<ArrayBuffer>;
    record: RecordValue;
}>;
export type DiffResult = Readonly<{
    added: ReadonlyArray<RecordValue>;
    removed: ReadonlyArray<RecordValue>;
}>;
declare const IdentifierType: typeof Proto.ManifestRecord.Identifier.Type;
type IdentifierType = Proto.ManifestRecord.Identifier.Type;
export type ToStorageItemOptions = Readonly<{
    storageKey: Buffer<ArrayBuffer>;
    recordIkm: Buffer<ArrayBuffer> | undefined;
}>;
export type CreateWriteOperationOptions = Readonly<{
    storageKey: Buffer<ArrayBuffer>;
    recordIkm: Buffer<ArrayBuffer> | undefined;
    previous?: StorageState;
}>;
type StorageRecordPredicate<Value extends RecordValue> = (record: StorageStateRecord) => record is StorageStateRecord<Value>;
type StorageRecordMapper<Value extends RecordValue> = (record: Value) => Value;
type StorageItemPredicate<Value extends RecordValue> = (item: StorageStateItem, index: number) => item is StorageStateItem<Value>;
declare class StorageStateItem<Value extends RecordValue = RecordValue> {
    readonly type: IdentifierType;
    readonly key: Buffer<ArrayBuffer>;
    readonly record: Value;
    constructor({ type, key, record }: StorageStateRecord<Value>);
    getKeyString(): string;
    toStorageItem({ storageKey, recordIkm, }: ToStorageItemOptions): Proto.StorageItem.Params;
    toIdentifier(): Proto.ManifestRecord.Identifier.Params;
    isAccount(): this is StorageStateItem<Extract<RecordValue, {
        account: unknown;
    }>>;
    isGroup(group: Group): this is StorageStateItem<Extract<RecordValue, {
        groupV2: unknown;
    }>>;
    isContact(device: Device, serviceIdKind: ServiceIdKind): this is StorageStateItem<Extract<RecordValue, {
        contact: unknown;
    }>>;
    inspect(): string;
    toRecord(): StorageStateRecord<Value>;
}
export declare class StorageState {
    readonly version: bigint;
    private readonly items;
    constructor(version: bigint, items: ReadonlyArray<StorageStateRecord>);
    static getEmpty(): StorageState;
    getAccountRecord(): Proto.AccountRecord.Params | undefined;
    updateAccount(diff: Partial<Proto.AccountRecord.Params>): StorageState;
    updateManyAccounts(diff: Partial<Proto.AccountRecord.Params>): StorageState;
    getGroup(group: Group): Proto.GroupV2Record.Params | undefined;
    addGroup(group: Group, diff?: Partial<Proto.GroupV2Record.Params>): StorageState;
    updateGroup(group: Group, diff: Partial<Proto.GroupV2Record.Params>): StorageState;
    pinGroup(group: Group): StorageState;
    unpinGroup(group: Group): StorageState;
    isGroupPinned(group: Group): boolean;
    addContact({ device }: PrimaryDevice, diff?: Partial<Proto.ContactRecord.Params>, serviceIdKind?: ServiceIdKind): StorageState;
    updateContact({ device }: PrimaryDevice, diff: Partial<Proto.ContactRecord.Params>, serviceIdKind?: ServiceIdKind): StorageState;
    getContact({ device }: PrimaryDevice, serviceIdKind?: ServiceIdKind): Proto.ContactRecord.Params | undefined;
    removeContact({ device }: PrimaryDevice, serviceIdKind?: ServiceIdKind): StorageState;
    mergeContact(primary: PrimaryDevice, diff: Partial<Proto.ContactRecord.Params>): StorageState;
    pin(primary: PrimaryDevice, serviceIdKind?: ServiceIdKind): StorageState;
    unpin(primary: PrimaryDevice, serviceIdKind?: ServiceIdKind): StorageState;
    isPinned({ device }: PrimaryDevice): boolean;
    addRecord(newRecord: StorageStateNewRecord): StorageState;
    findRecord<Value extends RecordValue>(find: StorageRecordPredicate<Value>): StorageStateRecord<Value> | undefined;
    filterRecords<Value extends RecordValue>(filter: StorageRecordPredicate<Value>): ReadonlyArray<StorageStateRecord<Value>>;
    hasRecord(find: (record: StorageStateRecord) => boolean): boolean;
    updateRecord<Value extends RecordValue>(find: StorageRecordPredicate<Value>, map: StorageRecordMapper<Value>): StorageState;
    updateManyRecords<Value extends RecordValue>(filter: StorageRecordPredicate<Value>, map: StorageRecordMapper<Value>): StorageState;
    removeRecord(find: (record: StorageStateRecord) => boolean): StorageState;
    removeManyRecords(filter: (record: StorageStateRecord) => boolean): StorageState;
    getAllGroupRecords(): ReadonlyArray<StorageStateRecord<Extract<RecordValue, {
        groupV2: unknown;
    }>>>;
    hasKey(storageKey: Buffer<ArrayBuffer>): boolean;
    createWriteOperation({ storageKey, recordIkm, previous, }: CreateWriteOperationOptions): Proto.WriteOperation.Params;
    inspect(): string;
    diff(oldState: StorageState): DiffResult;
    private addItem;
    private findItemIndex;
    private updateItem;
    updateManyItems<Value extends RecordValue>(filter: StorageItemPredicate<Value>, map: StorageRecordMapper<Value>): StorageState;
    private replaceItem;
    private removeItem;
    private removeManyItems;
    private changePin;
    private changeGroupPin;
    private static createStorageID;
}
export {};