@interncom/diplomatic 0.0.75 → 0.1.0

package/dist/shared/types.d.ts

@@ -1,78 +1,156 @@
-export declare enum Verb {
-    DELETE = 0,
-    UPSERT = 1
-}
-type Timestamp = string;
-export type GroupID = Uint8Array | string;
-export type EntityID = Uint8Array;
-export interface IBaseOp {
-    eid: EntityID;
-    ts: Timestamp;
-    type: string;
-    ver: number;
-}
-export interface IUpsertOp extends IBaseOp {
+import { IClock } from "./clock.ts";
+import { Decoder, Encoder } from "./codec.ts";
+import { IAuthTimestamp } from "./codecs/authTimestamp.ts";
+import type { IBagPeekItem } from "./codecs/peekItem.ts";
+import { IUsageQuota } from "./codecs/usageQuota.ts";
+import { APICallName, Status } from "./consts.ts";
+import { ValStat } from "./valstat.ts";
+export type GroupID = string;
+declare const entityIDSymbol: unique symbol;
+export type EntityID = Uint8Array & {
+    readonly [entityIDSymbol]: true;
+};
+export type SerializedContent = Uint8Array;
+export interface IMsgEntBody<T = unknown> {
     gid?: GroupID;
     pid?: EntityID;
-    verb: Verb.UPSERT;
-    body: unknown;
+    type: string;
+    body?: T;
 }
-export interface IDeleteOp extends IBaseOp {
-    verb: Verb.DELETE;
+export interface IMessageHead {
+    eid: EntityID;
+    off: number;
+    ctr: number;
+    len: number;
+    hsh?: Uint8Array;
+}
+export interface IMessage extends IMessageHead {
+    bod?: SerializedContent;
 }
-export type IOp = IUpsertOp | IDeleteOp;
-export type CipherOp = Uint8Array;
-export interface ISyncRequest {
-    ops: CipherOp[];
-    begin: Timestamp;
+export interface IMessageWithHash extends IMessage {
+    headHash: Hash;
 }
-export interface IRegistrationRequest {
-    token: string;
-    pubKey: Uint8Array;
+export interface IDeleteOp extends Omit<IMessageHead, "len" | "hsh" | "bod"> {
 }
-export interface IOperationRequest {
-    cipher: Uint8Array;
+export interface IMutateOp<T = unknown> extends IDeleteOp, Omit<IMsgEntBody<T>, "body"> {
+    body: T;
 }
-export interface IDeltaListItem {
-    sha256: Uint8Array;
-    recordedAt: Date;
+export type IOp = IDeleteOp | IMutateOp;
+export declare function isDeleteOp(op: IOp): op is IDeleteOp;
+export declare function isMutateOp(op: IOp): op is IMutateOp;
+export interface IInsertParams<T> extends IMsgEntBody<T> {
+    id?: Uint8Array;
 }
-export interface IListDeltasResponse {
-    deltas: IDeltaListItem[];
-    fetchedAt: string;
+export interface IUpsertParams<T> extends IMsgEntBody<T> {
+    eid?: EntityID;
 }
 export interface IStorage {
-    addUser: (pubKeyHex: string) => Promise<void>;
-    hasUser: (pubKeyHex: string) => Promise<boolean>;
-    setOp: (pubKeyHex: string, recordedAt: Date, op: Uint8Array) => Promise<void>;
-    getOp: (pubKeyHex: string, sha256Hex: string) => Promise<Uint8Array | undefined>;
-    listOps: (pubKeyHex: string, begin: string, end: string) => Promise<IDeltaListItem[]>;
+    addUser: (pubKey: PublicKey) => Promise<ValStat<void>>;
+    hasUser: (pubKey: PublicKey) => Promise<ValStat<boolean>>;
+    subMeta: (pubKey: PublicKey) => Promise<ValStat<ISubscriptionMetadata>>;
+    setBag: (pubKey: PublicKey, bag: IBag) => Promise<ValStat<number>>;
+    getBody: (pubKey: PublicKey, seq: number) => Promise<ValStat<Uint8Array | undefined>>;
+    listHeads: (pubKey: PublicKey, minSeq: number) => Promise<ValStat<IBagPeekItem[]>>;
 }
 export interface KeyPair {
     keyType: "public" | "private" | "secret";
-    privateKey: Uint8Array;
-    publicKey: Uint8Array;
+    privateKey: PrivateKey;
+    publicKey: PublicKey;
 }
+declare const masterSeedSymbol: unique symbol;
+declare const derivationSeedSymbol: unique symbol;
+declare const publicKeySymbol: unique symbol;
+declare const privateKeySymbol: unique symbol;
+declare const hostSpecificKeyPairSymbol: unique symbol;
+declare const hashSymbol: unique symbol;
+export type MasterSeed = Uint8Array & {
+    readonly [masterSeedSymbol]: true;
+};
+export type DerivationSeed = Uint8Array & {
+    readonly [derivationSeedSymbol]: true;
+};
+export type PublicKey = Uint8Array & {
+    readonly [publicKeySymbol]: true;
+};
+export type PrivateKey = Uint8Array & {
+    readonly [privateKeySymbol]: true;
+};
+export type HostSpecificKeyPair = KeyPair & {
+    readonly [hostSpecificKeyPairSymbol]: true;
+};
+export type Hash = Uint8Array & {
+    readonly [hashSymbol]: true;
+};
 export interface IHostCrypto {
-    checkSigEd25519: (sig: Uint8Array, message: Uint8Array | string, pubKey: Uint8Array) => Promise<boolean>;
-    sha256Hash: (data: Uint8Array) => Promise<Uint8Array>;
+    checkSigEd25519: (sig: Uint8Array, message: Uint8Array | string, pubKey: PublicKey) => Promise<boolean>;
 }
 export interface ICrypto extends IHostCrypto {
-    gen128BitRandomID: () => Promise<Uint8Array>;
+    genRandomBytes: (bytes: number) => Promise<Uint8Array>;
     gen256BitSecureRandomSeed: () => Promise<Uint8Array>;
     deriveXSalsa20Poly1305Key: (seed: Uint8Array, derivationIndex: number) => Promise<Uint8Array>;
     encryptXSalsa20Poly1305Combined: (plaintext: Uint8Array, key: Uint8Array) => Promise<Uint8Array>;
     decryptXSalsa20Poly1305Combined: (headerAndCipher: Uint8Array, key: Uint8Array) => Promise<Uint8Array>;
-    deriveEd25519KeyPair: (seed: Uint8Array, hostID: string, derivationIndex: number) => Promise<KeyPair>;
-    signEd25519: (message: Uint8Array | string, secKey: Uint8Array) => Promise<Uint8Array>;
+    deriveEd25519KeyPair: (derivationSeed: DerivationSeed) => Promise<KeyPair>;
+    signEd25519: (message: Uint8Array | string, secKey: PrivateKey) => Promise<Uint8Array>;
+    blake3: (data: Uint8Array) => Promise<Hash>;
 }
 export interface IMsgpackCodec {
     encode: (source: unknown) => Uint8Array;
     decode: (packed: ArrayBuffer | Uint8Array) => unknown;
     decodeAsync: (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
 }
-export interface IWebsocketNotifier {
-    handler: (request: Request, hasUser: (pubKeyHex: string) => Promise<boolean>) => Promise<Response>;
-    notify: (pubKeyHex: string) => Promise<void>;
+export interface IProtoHost {
+    storage: IStorage;
+    crypto: IHostCrypto;
+    notifier: IPushNotifier;
+    clock: IClock;
+}
+export type PushReceiver = (data: Uint8Array) => void;
+export interface IPushOpenResponse {
+    send: (data: Uint8Array) => Status;
+    shut: () => Status;
+    status: Status;
+}
+export interface IPushNotifier {
+    open(authTS: IAuthTimestamp, recv: PushReceiver, crypto: IHostCrypto, clock: IClock): Promise<IPushOpenResponse>;
+    push(pubKey: PublicKey, data: Uint8Array): void;
+}
+export interface IWebSocketPushNotifier extends IPushNotifier {
+    handle(host: IProtoHost, req: Request): Promise<Response>;
+}
+export interface IPushListener {
+    connect(authTS: IAuthTimestamp, recv: PushReceiver, onDisconnect: () => void): Promise<Status>;
+    connected(): boolean;
+    disconnect(): void;
+}
+export interface IBagHeader {
+    sig: Uint8Array;
+    kdm: Uint8Array;
+}
+export interface IBag extends IBagHeader {
+    headCph: Uint8Array;
+    bodyCph: Uint8Array;
+}
+export type EncodedBag = Uint8Array;
+export type HostHandle = URL | IProtoHost;
+export interface IHostConnectionInfo<Handle extends HostHandle> {
+    handle: Handle;
+    label: string;
+    idx: number;
+}
+export interface ISubscriptionMetadata {
+    term: number;
+    elapsed: number;
+    stat: IUsageQuota;
+    dyn: IUsageQuota;
+}
+export declare const nullSubMeta: ISubscriptionMetadata;
+export interface IHostMetadata {
+    subscription: ISubscriptionMetadata;
+    clockOffset: number;
+}
+export interface ITransport {
+    call: (name: APICallName, enc: Encoder) => Promise<ValStat<Decoder>>;
+    listener: IPushListener;
 }
 export {};

package/dist/shared/valstat.d.ts

@@ -0,0 +1,6 @@
+import { Status } from "./consts.ts";
+export type StatusOK = Status.Success;
+export type StatusNOK = Exclude<Status, Status.Success>;
+export type ValStat<T> = [T, StatusOK] | [undefined, StatusNOK];
+export declare function ok<T>(val: T): ValStat<T>;
+export declare function err<T>(stat: StatusNOK): ValStat<T>;

package/dist/state.d.ts

@@ -1,21 +1,16 @@
-import { EventEmitter } from "./eventEmitter";
-import type { Applier } from "./types";
-import type { IOp } from "./shared/types";
-export declare class StateManager {
-    emitter: EventEmitter;
+import { Status } from "./shared/consts";
+import { IMessage, IMsgEntBody, IOp } from "./shared/types";
+import { ValStat } from "./shared/valstat";
+import type { Applier, IStateManager } from "./types";
+export declare function isMsgEntBody(bodDec: unknown): bodDec is IMsgEntBody;
+export declare function msgToOp(msg: IMessage): ValStat<IOp>;
+export declare class StateManager implements IStateManager {
     applier: Applier;
-    clear: () => Promise<void>;
-    constructor(applier: Applier, clear: () => Promise<void>);
-    apply: (op: IOp) => Promise<void>;
+    clear: () => Promise<Status>;
+    private emitter;
+    constructor(applier: Applier, clear: () => Promise<Status>);
+    apply: (msgs: IMessage[]) => Promise<Status[]>;
     on: (opType: string, listener: () => void) => void;
     off: (opType: string, listener: () => void) => void;
 }
-interface IApplier<T extends IOp> {
-    check: (op: IOp) => op is T;
-    apply: (op: T) => Promise<void>;
-}
-type Appliers<M> = {
-    [K in keyof M]: M[K] extends IOp ? IApplier<M[K]> : never;
-};
-export declare function opMapApplier<M>(appliers: Appliers<M>): (op: IOp) => Promise<void>;
-export {};
+export declare const nullStateManager: IStateManager;

package/dist/stores/idb/dnlds.d.ts

@@ -0,0 +1,10 @@
+import { IDownloadMessage, IDownloadQueue } from "../../types";
+export declare class IDBDownloadQueue implements IDownloadQueue {
+    db: IDBDatabase;
+    constructor(db: IDBDatabase);
+    enq(msgs: Iterable<IDownloadMessage>): Promise<void>;
+    deq(host: string, seqs: Iterable<number>): Promise<void>;
+    list(): Promise<IDownloadMessage[]>;
+    count(): Promise<number>;
+    wipe(): Promise<void>;
+}

package/dist/stores/idb/hosts.d.ts

@@ -0,0 +1,15 @@
+import { Status } from "../../shared/consts";
+import { IHostConnectionInfo, IHostMetadata } from "../../shared/types";
+import type { IHostRow, IHostStore } from "../../types";
+export declare class IDBHostStore implements IHostStore<URL> {
+    db: IDBDatabase;
+    constructor(db: IDBDatabase);
+    add(info: IHostConnectionInfo<URL>): Promise<void>;
+    private put;
+    touch(label: string, seq: number): Promise<void>;
+    get(label: string): Promise<IHostRow<URL> | undefined>;
+    set(label: string, meta: IHostMetadata): Promise<Status.Success | Status.NotFound | Status.DatabaseError>;
+    del(label: string): Promise<void>;
+    list(): Promise<IHostRow<URL>[]>;
+    wipe(): Promise<void>;
+}

package/dist/stores/idb/msgs.d.ts

@@ -0,0 +1,19 @@
+import { Status } from "../../shared/consts";
+import { ICrypto } from "../../shared/types";
+import { EntityID, Hash } from "../../shared/types";
+import { IMessageStore, IStoredMessage, IStoredMessageData } from "../../types";
+export declare class IDBMessageStore implements IMessageStore {
+    private crypto;
+    db: IDBDatabase;
+    constructor(db: IDBDatabase, crypto: ICrypto);
+    add(messages: {
+        key: Hash;
+        data: IStoredMessageData;
+    }[]): Promise<Status[]>;
+    del(keys: Iterable<Hash>): Promise<void>;
+    get(key: Hash): Promise<IStoredMessage | undefined>;
+    has(key: Hash): Promise<boolean>;
+    list(): Promise<Iterable<IStoredMessage>>;
+    last(eid: EntityID): Promise<IStoredMessage | undefined>;
+    wipe(): Promise<void>;
+}

package/dist/stores/idb/seed.d.ts

@@ -0,0 +1,11 @@
+import { Enclave } from "../../shared/enclave";
+import { MasterSeed } from "../../shared/types";
+import { ISeedStore } from "../../types";
+export declare class IDBSeedStore implements ISeedStore {
+    enclave?: Enclave;
+    db: IDBDatabase;
+    constructor(db: IDBDatabase);
+    save(seed: MasterSeed): Promise<Enclave>;
+    load(): Promise<Enclave | undefined>;
+    wipe(): Promise<void>;
+}

package/dist/stores/idb/store.d.ts

@@ -0,0 +1,23 @@
+import { ICrypto } from "../../shared/types";
+import { IStore } from "../../types";
+import { IDBDownloadQueue } from "./dnlds";
+import { IDBHostStore } from "./hosts";
+import { IDBMessageStore } from "./msgs";
+import { IDBSeedStore } from "./seed";
+import { IDBUploadQueue } from "./uplds";
+export declare const SEED_META_TABLE = "seedMeta";
+export declare const HOSTS_TABLE = "hosts";
+export declare const UPLOAD_QUEUE_TABLE = "uploadQueue";
+export declare const DOWNLOAD_QUEUE_TABLE = "downloadQueue";
+export declare const MESSAGES_TABLE = "messages";
+export declare class IDBStore implements IStore<URL> {
+    seed: IDBSeedStore;
+    hosts: IDBHostStore;
+    uploads: IDBUploadQueue;
+    downloads: IDBDownloadQueue;
+    messages: IDBMessageStore;
+    db: IDBDatabase;
+    constructor(db: IDBDatabase, crypto: ICrypto);
+    wipe(): Promise<void>;
+}
+export declare function openIDBStore(): Promise<IDBDatabase>;

package/dist/stores/idb/uplds.d.ts

@@ -0,0 +1,11 @@
+import { Hash } from "../../shared/types";
+import { IUploadQueue } from "../../types";
+export declare class IDBUploadQueue implements IUploadQueue {
+    db: IDBDatabase;
+    constructor(db: IDBDatabase);
+    enq(host: string, hshs: Iterable<Hash>): Promise<void>;
+    deq(host: string, hshs: Iterable<Hash>): Promise<void>;
+    list(host: string): Promise<Hash[]>;
+    count(): Promise<number>;
+    wipe(): Promise<void>;
+}

package/dist/stores/memory/dnlds.d.ts

@@ -0,0 +1,9 @@
+import { IDownloadMessage, IDownloadQueue } from "../../types";
+export declare class MemoryDownloadQueue implements IDownloadQueue {
+    queue: Map<string, IDownloadMessage>;
+    enq(msgs: Iterable<IDownloadMessage>): Promise<void>;
+    deq(host: string, seqs: Iterable<number>): Promise<void>;
+    list(): Promise<IDownloadMessage[]>;
+    count(): Promise<number>;
+    wipe(): Promise<void>;
+}

package/dist/stores/memory/hosts.d.ts

@@ -0,0 +1,13 @@
+import { Status } from "../../shared/consts";
+import { HostHandle, IHostConnectionInfo, IHostMetadata } from "../../shared/types";
+import type { IHostRow, IHostStore } from "../../types";
+export declare class MemoryHostStore<Handle extends HostHandle> implements IHostStore<Handle> {
+    hosts: Map<string, IHostRow<Handle>>;
+    add(info: IHostConnectionInfo<Handle>): Promise<void>;
+    touch(label: string, seq: number): Promise<void>;
+    get(label: string): Promise<IHostRow<Handle> | undefined>;
+    set(label: string, meta: IHostMetadata): Promise<Status.Success | Status.NotFound>;
+    del(label: string): Promise<void>;
+    list(): Promise<MapIterator<IHostRow<Handle>>>;
+    wipe(): Promise<void>;
+}

package/dist/stores/memory/msgs.d.ts

@@ -0,0 +1,19 @@
+import { ICrypto } from "../../shared/types";
+import { EntityID, Hash } from "../../shared/types";
+import { IMessageStore, IStoredMessage, IStoredMessageData } from "../../types";
+import { Status } from "../../shared/consts";
+export declare class MemoryMessageStore implements IMessageStore {
+    private crypto;
+    messages: Map<string, IStoredMessageData>;
+    constructor(crypto: ICrypto);
+    add(messages: {
+        key: Hash;
+        data: IStoredMessageData;
+    }[]): Promise<Status[]>;
+    del(keys: Iterable<Hash>): Promise<void>;
+    get(key: Hash): Promise<IStoredMessage | undefined>;
+    has(key: Hash): Promise<boolean>;
+    list(): Promise<Iterable<IStoredMessage>>;
+    last(eid: EntityID): Promise<IStoredMessage | undefined>;
+    wipe(): Promise<void>;
+}

package/dist/stores/memory/seed.d.ts

@@ -0,0 +1,9 @@
+import { Enclave } from "../../shared/enclave";
+import { MasterSeed } from "../../shared/types";
+import { ISeedStore } from "../../types";
+export declare class MemorySeedStore implements ISeedStore {
+    enclave?: Enclave;
+    save(seed: MasterSeed): Promise<Enclave>;
+    load(): Promise<Enclave | undefined>;
+    wipe(): Promise<void>;
+}

package/dist/stores/memory/store.d.ts

@@ -0,0 +1,16 @@
+import { HostHandle, ICrypto } from "../../shared/types";
+import { IStore } from "../../types";
+import { MemoryDownloadQueue } from "./dnlds";
+import { MemoryHostStore } from "./hosts";
+import { MemoryMessageStore } from "./msgs";
+import { MemorySeedStore } from "./seed";
+import { MemoryUploadQueue } from "./uplds";
+export declare class MemoryStore<Handle extends HostHandle> implements IStore<Handle> {
+    seed: MemorySeedStore;
+    hosts: MemoryHostStore<Handle>;
+    uploads: MemoryUploadQueue;
+    downloads: MemoryDownloadQueue;
+    messages: MemoryMessageStore;
+    constructor(crypto: ICrypto);
+    wipe(): Promise<void>;
+}

package/dist/stores/memory/uplds.d.ts

@@ -0,0 +1,10 @@
+import { Hash } from "../../shared/types";
+import { IUploadQueue } from "../../types";
+export declare class MemoryUploadQueue implements IUploadQueue {
+    queue: Map<string, Set<string>>;
+    enq(host: string, hshs: Iterable<Hash>): Promise<void>;
+    deq(host: string, hshs: Iterable<Hash>): Promise<void>;
+    list(host: string): Promise<Hash[]>;
+    count(): Promise<number>;
+    wipe(): Promise<void>;
+}

package/dist/sync.d.ts

@@ -1,2 +1,32 @@
-import type DiplomaticClient from "./client";
-export declare function usePollingSync(client: DiplomaticClient, intervalMillis: number): void;
+import DiplomaticClientAPI from "./shared/client";
+import { IClock } from "./shared/clock";
+import { IBagPeekItem } from "./shared/codecs/peekItem";
+import { Status } from "./shared/consts";
+import { Enclave } from "./shared/enclave";
+import { HostHandle, HostSpecificKeyPair, ICrypto } from "./shared/types";
+import { ValStat } from "./shared/valstat";
+import { IHostRow, IMsgParts, IStore, IStoredMessageData } from "./types";
+export interface IDecryptedBagPeekItem {
+    kdm: Uint8Array;
+    headEnc: Uint8Array;
+}
+export declare function decryptPeekItem(item: IBagPeekItem, hostKeys: HostSpecificKeyPair, enclave: Enclave, crypto: ICrypto): Promise<ValStat<IDecryptedBagPeekItem>>;
+export interface ISyncParams<Handle extends HostHandle> {
+    conn: DiplomaticClientAPI<Handle>;
+    store: IStore<Handle>;
+    enclave: Enclave;
+    clock: IClock;
+    host: IHostRow<Handle>;
+    crypto: ICrypto;
+}
+export declare function syncPeek<Handle extends HostHandle>({ conn, store, enclave, host, crypto }: ISyncParams<Handle>): Promise<Status>;
+export declare function syncPush<Handle extends HostHandle>({ conn, store, host }: ISyncParams<Handle>): Promise<Status>;
+export declare function syncPull<Handle extends HostHandle>({ conn, store, enclave, host, crypto }: ISyncParams<Handle>, apply: (parts: IMsgParts[], options?: {
+    enqueueUpload: boolean;
+    triggerUpload: boolean;
+}) => Promise<Status[]>): Promise<Status>;
+export declare function msg2StoredMsgData({ head, body }: IMsgParts): IStoredMessageData;
+export declare function handleNotif<Handle extends HostHandle>(bytes: Uint8Array, { conn, store, enclave, host, crypto, clock }: ISyncParams<Handle>, apply: (parts: IMsgParts[], options?: {
+    enqueueUpload: boolean;
+    triggerUpload: boolean;
+}) => Promise<Status[]>, scheduleSync: () => void): Promise<void>;

package/dist/types.d.ts

@@ -1,31 +1,12 @@
-import type { IDeltaListItem, IOp } from "./shared/types";
-export interface IClientStateStore {
-    init?: () => Promise<void>;
-    getSeed: () => Promise<Uint8Array | undefined>;
-    setSeed: (seed: Uint8Array) => Promise<void>;
-    getHostURL: () => Promise<string | undefined>;
-    setHostURL: (url: string) => Promise<void>;
-    getHostID: () => Promise<string | undefined>;
-    setHostID: (id: string) => Promise<void>;
-    setLastFetchedAt: (ts: Date) => Promise<void>;
-    getLastFetchedAt: () => Promise<Date | undefined>;
-    wipe: () => Promise<void>;
-    enqueueUpload: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
-    dequeueUpload: (sha256: Uint8Array) => Promise<void>;
-    peekUpload: (sha256: Uint8Array) => Promise<Uint8Array | undefined>;
-    listUploads: () => Promise<Uint8Array[]>;
-    numUploads: () => Promise<number>;
-    enqueueDownload: (sha256: Uint8Array, recordedAt: Date) => Promise<void>;
-    dequeueDownload: (sha256: Uint8Array) => Promise<void>;
-    listDownloads: () => Promise<IDeltaListItem[]>;
-    numDownloads: () => Promise<number>;
-    storeOp: (sha256: Uint8Array, cipherOp: Uint8Array) => Promise<void>;
-    clearOp: (sha256: Uint8Array) => Promise<void>;
-    listOps: () => Promise<Array<{
-        cipherOp: Uint8Array;
-        sha256: string;
-    }>>;
-    hasOp: (sha256: Uint8Array) => Promise<boolean>;
+import { Status } from "./shared/consts";
+import type { Enclave } from "./shared/enclave";
+import type { EncodedMessage } from "./shared/message";
+import type { EntityID, Hash, HostHandle, IHostConnectionInfo, IHostMetadata, IInsertParams, IMessage, IMessageHead, IOp, IUpsertParams, MasterSeed, SerializedContent } from "./shared/types";
+import { ValStat } from "./shared/valstat";
+import { ICrypto } from "./shared/types";
+export interface IMsgParts {
+    head: IMessageHead;
+    body?: EncodedMessage;
 }
 export interface IDiplomaticClientState {
     hasSeed: boolean;
@@ -36,4 +17,107 @@ export interface IDiplomaticClientXferState {
     numUploads: number;
     numDownloads: number;
 }
-export type Applier = (op: IOp) => Promise<void>;
+export type Applier = (ops: IOp[]) => Promise<{
+    stats: Status[];
+    types: Set<string>;
+}>;
+export interface ISeedStore {
+    save: (seed: MasterSeed) => Promise<Enclave>;
+    load: () => Promise<Enclave | void>;
+    wipe: () => Promise<void>;
+}
+export interface IHostRow<Handle extends HostHandle> extends IHostConnectionInfo<Handle>, Partial<IHostMetadata> {
+    lastSeq: number;
+}
+export interface IHostStore<Handle extends HostHandle> {
+    add: (host: IHostConnectionInfo<Handle>) => Promise<void>;
+    get: (label: string) => Promise<IHostRow<Handle> | undefined>;
+    del: (label: string) => Promise<void>;
+    set: (label: string, meta: IHostMetadata) => Promise<Status>;
+    list: () => Promise<Iterable<IHostRow<Handle>>>;
+    wipe: () => Promise<void>;
+    touch: (label: string, seq: number) => Promise<void>;
+}
+export interface IUploadQueue {
+    enq: (host: string, hshs: Iterable<Hash>) => Promise<void>;
+    deq: (host: string, hshs: Iterable<Hash>) => Promise<void>;
+    list: (host: string) => Promise<Hash[]>;
+    count: () => Promise<number>;
+    wipe(): Promise<void>;
+}
+export interface IDownloadMessage {
+    kdm: Uint8Array;
+    seq: number;
+    head: IMessageHead;
+    host: string;
+}
+export interface IDownloadQueue {
+    enq: (msgs: Iterable<IDownloadMessage>) => Promise<void>;
+    deq: (host: string, seqs: Iterable<number>) => Promise<void>;
+    list: () => Promise<Iterable<IDownloadMessage>>;
+    count: () => Promise<number>;
+    wipe(): Promise<void>;
+}
+export interface IStorableMessage {
+    key: Hash;
+    data: IStoredMessageData;
+}
+export interface IStoredMessage {
+    hash: Hash;
+    head: IMessageHead;
+    body?: EncodedMessage;
+}
+export interface IStoredMessageData {
+    eid: EntityID;
+    off?: number;
+    ctr?: number;
+    body?: EncodedMessage;
+}
+export declare function toStoredMessage(hash: Hash, data: IStoredMessageData, crypto: ICrypto): Promise<IStoredMessage>;
+export interface IMessageStore {
+    add: (messages: IStorableMessage[]) => Promise<Status[]>;
+    get: (key: Hash) => Promise<IStoredMessage | undefined>;
+    has: (key: Hash) => Promise<boolean>;
+    del: (keys: Iterable<Hash>) => Promise<void>;
+    list: () => Promise<Iterable<IStoredMessage>>;
+    last: (eid: EntityID) => Promise<IStoredMessage | undefined>;
+    wipe(): Promise<void>;
+}
+export interface IStore<Handle extends HostHandle> {
+    seed: ISeedStore;
+    hosts: IHostStore<Handle>;
+    uploads: IUploadQueue;
+    downloads: IDownloadQueue;
+    messages: IMessageStore;
+    wipe(): Promise<void>;
+}
+type UnlistenFunc = () => void;
+export interface IStateEmitter<T> {
+    get(): Promise<T>;
+    emit(): void;
+    listen(listener: (state: T) => void): UnlistenFunc;
+}
+export interface IClient<Handle extends HostHandle> {
+    setSeed(seed: MasterSeed): Promise<void>;
+    link(host: IHostConnectionInfo<Handle>): Promise<void>;
+    unlink(label: string): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    insertRaw(content: SerializedContent): Promise<ValStat<IMessageHead>>;
+    upsertRaw(eid: EntityID, content: SerializedContent, force?: boolean): Promise<ValStat<IMessageHead>>;
+    insert<T = unknown>(op: IInsertParams<T>): Promise<ValStat<IMessageHead>>;
+    upsert<T = unknown>(op: IUpsertParams<T>, force?: boolean): Promise<ValStat<IMessageHead>>;
+    delete(eid: EntityID): Promise<ValStat<IMessageHead>>;
+    sync(): Promise<Status>;
+    wipe(): Promise<void>;
+    import(file: File): Promise<Status>;
+    export(filename: string, extension?: string): Promise<Status>;
+    clientState: IStateEmitter<IDiplomaticClientState>;
+    xferState: IStateEmitter<IDiplomaticClientXferState>;
+}
+export interface IStateManager {
+    apply: (msgs: IMessage[]) => Promise<Status[]>;
+    on: (type: string, listener: () => void) => void;
+    off: (type: string, listener: () => void) => void;
+}
+export {};