import { type IdentityScope } from "@gryt/crypto";
import type { MlsDmDriver, MlsGroupRecord, MlsKeyPackageRecord, MlsDeviceRecord, MlsLogEntry, MlsStateStore, MlsTransport, MlsWelcomeDelivery } from "./interfaces.js";
interface KeyPackageRow {
    ref: string;
    serverUserId: string;
    deviceId: string;
    data: Uint8Array;
    lastResort: boolean;
    claimed: boolean;
}
interface GroupRow {
    conversationId: string;
    groupId: string;
    epoch: number;
    headSeq: number;
    log: MlsLogEntry[];
    info?: {
        epoch: number;
        data: Uint8Array;
    };
}
interface Socket {
    serverUserId: string;
    driver: MlsDmDriver | null;
    online: boolean;
    /** False: every call answers `offline` without reaching the server, as an app's transport does. */
    reachable: boolean;
    /** The next call to each method either never arrives or has its answer lost. Both answer `timeout`. */
    lose: Map<keyof MlsTransport, "request" | "answer">;
}
export declare class FakeDeliveryService {
    scope: IdentityScope;
    conversations: Map<string, string[]>;
    devices: Map<string, string[]>;
    /** Ids their owner removed, as `${serverUserId}:${deviceId}`. Anything naming one is refused (GRYT-1555). */
    removed: Set<string>;
    /** Every call that named a device, in order, by device id. */
    callsBy: Map<string, string[]>;
    /** When each device id first published, as `mls:devices` reports it. */
    deviceAddedAt: Map<string, string>;
    keyPackages: KeyPackageRow[];
    groups: Map<string, GroupRow>;
    welcomes: (MlsWelcomeDelivery & {
        serverUserId: string;
    })[];
    sockets: Socket[];
    stats: {
        commits: number;
        staleEpoch: number;
        groupExists: number;
        claims: number;
        publishes: number;
        mostBinaryParts: number;
    };
    /** A cap on Welcomes per sync, for a server that pages them (GRYT-1528). server#241 has none. */
    syncWelcomeLimit: number;
    /** What each `mls:send` said it carried, by seq. */
    attachmentIds: Map<number, string[] | undefined>;
    private inFlight;
    private held;
    private nextWelcome;
    constructor(scope: IdentityScope);
    dm(a: string, b: string): string;
    /** Commits wait until `count` of them are in, then go through in the order they came. */
    holdCommits(count: number): void;
    /** Waits until every push has been handled, including what those handlers set off. */
    settle(): Promise<void>;
    connect(serverUserId: string): {
        transport: MlsTransport;
        socket: Socket;
    };
    dropLogThrough(conversationId: string, seq: number): void;
    private push;
    private peopleSharing;
    private devicesOf;
    private isDevice;
    private groupView;
    private transportFor;
    private checkParts;
    private counts;
    private append;
    private commit;
}
/** What an app's store does, kept in maps and copied on the way in and out. */
export declare class MemoryMlsStore implements MlsStateStore {
    device: MlsDeviceRecord | null;
    keyPackages: Map<string, MlsKeyPackageRecord>;
    groups: Map<string, MlsGroupRecord>;
    loadDevice(): Promise<MlsDeviceRecord | null>;
    saveDevice(device: MlsDeviceRecord): Promise<void>;
    putKeyPackages(records: MlsKeyPackageRecord[]): Promise<void>;
    listKeyPackages(): Promise<MlsKeyPackageRecord[]>;
    getKeyPackage(ref: string): Promise<MlsKeyPackageRecord | null>;
    deleteKeyPackage(ref: string): Promise<void>;
    loadGroup(conversationId: string): Promise<MlsGroupRecord | null>;
    listGroups(): Promise<MlsGroupRecord[]>;
    saveGroup(record: MlsGroupRecord): Promise<void>;
    deleteGroup(conversationId: string): Promise<void>;
}
export {};