@fireproof/core 0.20.0-dev-preview-63 → 0.20.1-dev-preview-01

package/index.d.ts

@@ -1,15 +1,2742 @@
-export * from "./ledger.js";
-export * from "./database.js";
-export * from "./types.js";
-export * from "./crdt.js";
-export * from "./indexer.js";
-export { defaultWriteQueueOpts } from "./write-queue.js";
-export * as bs from "./blockstore/index.js";
-export * as blockstore from "./blockstore/index.js";
-export * as rt from "./runtime/index.js";
-export * as runtime from "./runtime/index.js";
-export * as ps from "./protocols/index.js";
-export * as protocols from "./protocols/index.js";
-export * from "./utils.js";
-export * from "./version.js";
-//# sourceMappingURL=index.d.ts.map
+import { Logger, Future, URI, CryptoRuntime, ResolveOnce, Result, ResolveSeq, CTCryptoKey, CoerceURI, Promisable, LRUSet, Env, EnvFactoryOpts, MatchResult, runtimeFn } from '@adviser/cement';
+import { EventLink } from '@web3-storage/pail/clock/api';
+import { Operation } from '@web3-storage/pail/crdt/api';
+import { Version, Block as Block$1, UnknownLink, CID, ByteView, ArrayBufferView, Link, MultihashHasher, BlockView } from 'multiformats';
+import { BlockFetcher as BlockFetcher$1 } from '@web3-storage/pail/api';
+import { EventBlock } from '@web3-storage/pail/clock';
+import { ProllyNode as ProllyNode$1 } from 'prolly-trees/db-index';
+import { Block as Block$2 } from 'multiformats/block';
+import * as jose from 'jose';
+import { JWTPayload, JWTVerifyResult } from 'jose';
+import { GenerateKeyPairOptions } from 'jose/key/generate/keypair';
+import { SuperThis as SuperThis$1 } from '@fireproof/core';
+
+type BlockFetcher = BlockFetcher$1;
+interface CarTransactionOpts {
+    readonly add: boolean;
+    readonly noLoader: boolean;
+}
+declare class CarTransactionImpl implements CarMakeable, CarTransaction {
+    #private;
+    readonly parent: BaseBlockstore;
+    constructor(parent: BaseBlockstore, opts?: CarTransactionOpts);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block$1<T, C, A, V> | undefined>;
+    superGet(cid: AnyLink): Promise<AnyBlock | undefined>;
+    put(cid: AnyLink, block: Uint8Array): Promise<void>;
+    putSync(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): void;
+    unshift(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): void;
+    entries(): AsyncIterableIterator<AnyBlock>;
+}
+declare class BaseBlockstoreImpl implements BlockFetcher {
+    readonly transactions: Set<CarTransaction>;
+    readonly ebOpts: BlockstoreRuntime;
+    readonly sthis: SuperThis;
+    readonly loader: Loadable;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    compact(): Promise<void>;
+    readonly logger: Logger;
+    constructor(ebOpts: BlockstoreOpts);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyAnyLink): Promise<Block$1<T, C, A, V> | undefined>;
+    put(cid: AnyAnyLink, block: Uint8Array): Promise<void>;
+    lastTxMeta?: unknown;
+    transaction<M extends TransactionMeta>(fn: (t: CarTransaction) => Promise<M>, _opts?: CarTransactionOpts): Promise<TransactionWrapper<M>>;
+    openTransaction(opts?: CarTransactionOpts): CarTransaction;
+    commitTransaction<M extends TransactionMeta>(t: CarTransaction, done: M, opts: CarTransactionOpts): Promise<TransactionWrapper<M>>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+}
+declare class EncryptedBlockstore extends BaseBlockstoreImpl {
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    compacting: boolean;
+    readonly logger: Logger;
+    constructor(sthis: SuperThis, ebOpts: BlockstoreOpts);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyAnyLink): Promise<Block$1<T, C, A, V> | undefined>;
+    transaction<M extends TransactionMeta>(fn: (t: CarTransaction) => Promise<M>, opts?: {
+        noLoader: boolean;
+    }): Promise<TransactionWrapper<M>>;
+    getFile(car: AnyLink, cid: AnyLink): Promise<Uint8Array>;
+    compact(): Promise<void>;
+    defaultCompact(blocks: CompactionFetcher, logger: Logger): Promise<TransactionMeta>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+}
+declare class CompactionFetcher implements BlockFetcher {
+    readonly blockstore: EncryptedBlockstore;
+    readonly loggedBlocks: CarTransaction;
+    constructor(blocks: EncryptedBlockstore);
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block$1<T, C, A, V> | undefined>;
+}
+
+type QueueFunction<T = void> = () => Promise<T>;
+declare class CommitQueue<T = void> {
+    readonly queue: QueueFunction<void>[];
+    processing: boolean;
+    readonly _waitIdleItems: Set<Future<void>>;
+    waitIdle(): Promise<void>;
+    enqueue(fn: QueueFunction<T>): Promise<T>;
+    processNext(): void;
+}
+
+declare class keyWithFingerPrint implements KeyWithFingerPrint {
+    #private;
+    readonly default: boolean;
+    readonly fingerPrint: string;
+    readonly key: CTCryptoKey;
+    private kfp;
+    constructor(kfp: KeyWithFingerPrint, material: string | Uint8Array, def: boolean);
+    extract(): Promise<KeyMaterial>;
+    asV2StorageKeyItem(): Promise<V2StorageKeyItem>;
+}
+declare function toKeyWithFingerPrint(keybag: KeyBag, materialStrOrUint8: string | Uint8Array): Promise<Result<KeyWithFingerPrint>>;
+declare class keysByFingerprint implements KeysByFingerprint {
+    readonly keys: Record<string, keyWithFingerPrint>;
+    readonly keybag: KeyBag;
+    readonly name: string;
+    readonly id: string;
+    static from(keyBag: KeyBag, named: KeysItem): Promise<KeysByFingerprint>;
+    constructor(keyBag: KeyBag, name: string);
+    get(fingerPrint?: Uint8Array | string): Promise<KeyWithFingerPrint | undefined>;
+    upsert(materialStrOrUint8: string | Uint8Array, def?: boolean, keyBagAction?: boolean): Promise<Result<KeyUpsertResult>>;
+    asKeysItem(): Promise<KeysItem>;
+}
+declare class KeyBag {
+    readonly logger: Logger;
+    readonly rt: KeyBagRuntime;
+    constructor(rt: KeyBagRuntime);
+    readonly _warnOnce: ResolveOnce<void>;
+    subtleKey(materialStrOrUint8: string | Uint8Array): Promise<CryptoKey>;
+    ensureKeyFromUrl(url: URI, keyFactory: () => string): Promise<Result<URI>>;
+    private toKeysItem;
+    flush(): Promise<void>;
+    readonly _seq: ResolveSeq<Result<KeysByFingerprint>>;
+    _upsertNamedKey(ksi: KeysByFingerprint): Promise<Result<KeysByFingerprint>>;
+    private _namedKeyCache;
+    private _getNamedKey;
+    getNamedKey(name: string, failIfNotFound?: boolean, material?: string | Uint8Array): Promise<Result<KeysByFingerprint>>;
+}
+interface V1StorageKeyItem {
+    readonly name: string;
+    readonly key: string;
+}
+interface V2StorageKeyItem {
+    readonly key: string;
+    readonly fingerPrint: string;
+    readonly default: boolean;
+}
+interface KeysItem {
+    readonly name: string;
+    readonly keys: Record<string, V2StorageKeyItem>;
+}
+type KeyBagFile = Record<string, KeysItem>;
+interface KeyBagOpts {
+    readonly url: CoerceURI;
+    readonly crypto: CryptoRuntime;
+    readonly keyLength: number;
+    readonly keyRuntime: KeyBagRuntime;
+}
+interface KeyBagProvider {
+    get(id: string): Promise<V1StorageKeyItem | KeysItem | undefined>;
+    set(item: KeysItem): Promise<void>;
+}
+interface KeyBagRuntime {
+    readonly url: URI;
+    readonly crypto: CryptoRuntime;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    readonly keyLength: number;
+    getBagProvider(): Promise<KeyBagProvider>;
+    id(): string;
+}
+type KeyBackProviderFactory = (url: URI, sthis: SuperThis) => Promise<KeyBagProvider>;
+interface KeyBagProviderFactoryItem {
+    readonly protocol: string;
+    readonly override?: boolean;
+    readonly factory: KeyBackProviderFactory;
+}
+declare function registerKeyBagProviderFactory(item: KeyBagProviderFactoryItem): void;
+declare function defaultKeyBagUrl(sthis: SuperThis): URI;
+declare function defaultKeyBagOpts(sthis: SuperThis, kbo?: Partial<KeyBagOpts>): KeyBagRuntime;
+declare function getKeyBag(sthis: SuperThis, kbo?: Partial<KeyBagOpts>): Promise<KeyBag>;
+
+type keyBag_KeyBackProviderFactory = KeyBackProviderFactory;
+type keyBag_KeyBag = KeyBag;
+declare const keyBag_KeyBag: typeof KeyBag;
+type keyBag_KeyBagFile = KeyBagFile;
+type keyBag_KeyBagOpts = KeyBagOpts;
+type keyBag_KeyBagProvider = KeyBagProvider;
+type keyBag_KeyBagProviderFactoryItem = KeyBagProviderFactoryItem;
+type keyBag_KeyBagRuntime = KeyBagRuntime;
+type keyBag_KeysItem = KeysItem;
+type keyBag_V1StorageKeyItem = V1StorageKeyItem;
+type keyBag_V2StorageKeyItem = V2StorageKeyItem;
+declare const keyBag_defaultKeyBagOpts: typeof defaultKeyBagOpts;
+declare const keyBag_defaultKeyBagUrl: typeof defaultKeyBagUrl;
+declare const keyBag_getKeyBag: typeof getKeyBag;
+type keyBag_keysByFingerprint = keysByFingerprint;
+declare const keyBag_keysByFingerprint: typeof keysByFingerprint;
+declare const keyBag_registerKeyBagProviderFactory: typeof registerKeyBagProviderFactory;
+declare const keyBag_toKeyWithFingerPrint: typeof toKeyWithFingerPrint;
+declare namespace keyBag {
+  export { type keyBag_KeyBackProviderFactory as KeyBackProviderFactory, keyBag_KeyBag as KeyBag, type keyBag_KeyBagFile as KeyBagFile, type keyBag_KeyBagOpts as KeyBagOpts, type keyBag_KeyBagProvider as KeyBagProvider, type keyBag_KeyBagProviderFactoryItem as KeyBagProviderFactoryItem, type keyBag_KeyBagRuntime as KeyBagRuntime, type keyBag_KeysItem as KeysItem, type keyBag_V1StorageKeyItem as V1StorageKeyItem, type keyBag_V2StorageKeyItem as V2StorageKeyItem, keyBag_defaultKeyBagOpts as defaultKeyBagOpts, keyBag_defaultKeyBagUrl as defaultKeyBagUrl, keyBag_getKeyBag as getKeyBag, keyBag_keysByFingerprint as keysByFingerprint, keyBag_registerKeyBagProviderFactory as registerKeyBagProviderFactory, keyBag_toKeyWithFingerPrint as toKeyWithFingerPrint };
+}
+
+interface TaskManagerParams {
+    readonly removeAfter: number;
+    readonly retryTimeout: number;
+}
+declare class TaskManager {
+    private readonly eventsWeHandled;
+    private queue;
+    private isProcessing;
+    readonly logger: Logger;
+    readonly params: TaskManagerParams;
+    readonly callback: (dbMeta: DbMeta, store: ActiveStore) => Promise<void>;
+    constructor(sthis: SuperThis, callback: (dbMeta: DbMeta, store: ActiveStore) => Promise<void>, params: TaskManagerParams);
+    handleEvent(cid: CarClockLink, parents: CarClockHead, dbMeta: DbMeta, store: ActiveStore): Promise<void>;
+    private processQueue;
+}
+
+declare function onSuperThis(fn: (sthis: SuperThis) => void): () => void;
+declare function ensureSuperThis(osthis?: Partial<SuperThisOpts>): SuperThis;
+declare function ensureSuperLog(sthis: SuperThis, componentName: string, ctx?: Record<string, unknown>): SuperThis;
+declare function ensureLogger(sthis: SuperThis, componentName: string, ctx?: Record<string, unknown>): Logger;
+type Joiner = (...toJoin: string[]) => string;
+interface Store {
+    readonly pathPart: "data" | "wal" | "meta";
+    readonly fromUrl: StoreType;
+    readonly name: string;
+}
+declare function getStore(url: URI, sthis: SuperThis, joiner: Joiner): Store;
+declare function getKey(url: URI, logger: Logger): string;
+declare function getName(sthis: SuperThis, url: URI): string;
+declare function exceptionWrapper<T, E extends Error>(fn: () => Promise<Result<T, E>>): Promise<Result<T, E>>;
+declare class NotFoundError extends Error {
+    readonly code = "ENOENT";
+}
+declare function isNotFoundError(e: Error | Result<unknown> | unknown): e is NotFoundError;
+declare function UInt8ArrayEqual(a: Uint8Array, b: Uint8Array): boolean;
+declare function inplaceFilter<T>(i: T[], pred: (i: T, idx: number) => boolean): T[];
+declare function toSortedArray(set?: Record<string, unknown>): Record<string, unknown>[];
+declare function coerceIntoUint8(raw: ToUInt8): Result<Uint8Array>;
+declare function coercePromiseIntoUint8(raw: PromiseToUInt8): Promise<Result<Uint8Array>>;
+declare function makeName(fnString: string): string;
+declare function storeType2DataMetaWal(store: StoreType): "data" | "wal" | "meta";
+declare function ensureURIDefaults(sthis: SuperThis, name: string, curi: CoerceURI | undefined, uri: URI, store: StoreType, ctx?: Partial<{
+    readonly idx: boolean;
+    readonly file: boolean;
+}>): URI;
+declare function setPresetEnv(o: Record<string, string>, symbol?: string): Record<string, string>;
+
+declare const FPEnvelopeTypes: {
+    readonly CAR: "car";
+    readonly FILE: "file";
+    readonly META: "meta";
+    readonly WAL: "wal";
+};
+type FPEnvelopeType = (typeof FPEnvelopeTypes)[keyof typeof FPEnvelopeTypes];
+interface FPEnvelope<T> {
+    readonly type: FPEnvelopeType;
+    readonly payload: T;
+}
+interface FPEnvelopeCar extends FPEnvelope<Uint8Array> {
+    readonly type: typeof FPEnvelopeTypes.CAR;
+}
+interface FPEnvelopeFile extends FPEnvelope<Uint8Array> {
+    readonly type: typeof FPEnvelopeTypes.FILE;
+}
+interface FPEnvelopeMeta extends FPEnvelope<DbMetaEvent[]> {
+    readonly type: typeof FPEnvelopeTypes.META;
+}
+interface FPWALCarsOps {
+    readonly cars: CID[];
+}
+interface FPEnvelopeWAL extends FPEnvelope<WALState> {
+    readonly type: typeof FPEnvelopeTypes.WAL;
+}
+declare function Car2FPMsg(fpcar: Uint8Array): Result<FPEnvelopeCar>;
+declare function File2FPMsg(fpfile: Uint8Array): Result<FPEnvelopeFile>;
+
+interface SerializedMeta {
+    readonly data: string;
+    readonly parents: string[];
+    readonly cid: string;
+}
+declare function dbMetaEvent2Serialized(sthis: SuperThis, dbEvents: Omit<DbMetaEvent, "eventCid">[]): Promise<SerializedMeta[]>;
+type CAREncodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
+type FILEEncodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
+type METAEncodeEnvelope = (sthis: SuperThis, payload: SerializedMeta[]) => Promise<Result<Uint8Array>>;
+type WALEncodeEnvelope = (sthis: SuperThis, payload: SerializedWAL) => Promise<Result<Uint8Array>>;
+interface FPEncoder {
+    readonly car: CAREncodeEnvelope;
+    readonly file: FILEEncodeEnvelope;
+    readonly meta: METAEncodeEnvelope;
+    readonly wal: WALEncodeEnvelope;
+}
+declare function fpSerialize<T>(sthis: SuperThis, env: FPEnvelope<T>, pencoder?: Partial<FPEncoder>): Promise<Result<Uint8Array>>;
+declare function decode2DbMetaEvents(sthis: SuperThis, rserializedMeta: Result<SerializedMeta[]>): Promise<Result<DbMetaEvent[]>>;
+type linkOrCid = {
+    "/": string;
+} | string;
+interface SerializedWAL {
+    readonly fileOperations?: {
+        cid: linkOrCid;
+        public: boolean;
+    }[];
+    readonly noLoaderOps?: {
+        cars: linkOrCid[];
+    }[];
+    readonly operations?: {
+        cars: linkOrCid[];
+    }[];
+}
+type CARDecodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
+type FILEDecodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<Uint8Array>>;
+type METADecodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<SerializedMeta[]>>;
+type WALDecodeEnvelope = (sthis: SuperThis, payload: Uint8Array) => Promise<Result<SerializedWAL>>;
+interface FPDecoder {
+    readonly car: CARDecodeEnvelope;
+    readonly file: FILEDecodeEnvelope;
+    readonly meta: METADecodeEnvelope;
+    readonly wal: WALDecodeEnvelope;
+}
+declare function fpDeserialize<S>(sthis: SuperThis, url: URI, intoRaw: PromiseToUInt8, pdecoder?: Partial<FPDecoder>): Promise<Result<FPEnvelope<S>>>;
+
+interface SerdeGatewayOpts {
+    readonly gateway: SerdeGateway;
+}
+type SerdeGetResult<S> = Result<FPEnvelope<S>, NotFoundError | Error>;
+type VoidResult = Result<void>;
+type UnsubscribeResult = Result<() => void>;
+interface SerdeGatewayCtx {
+    readonly loader: Loadable;
+    readonly encoder?: Partial<FPEncoder>;
+    readonly decoder?: Partial<FPDecoder>;
+}
+interface SerdeGateway {
+    buildUrl(ctx: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<URI>>;
+    start(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<URI>>;
+    close(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<VoidResult>;
+    put<T>(ctx: SerdeGatewayCtx, url: URI, body: FPEnvelope<T>): Promise<VoidResult>;
+    get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<SerdeGetResult<S>>;
+    delete(ctx: SerdeGatewayCtx, url: URI): Promise<VoidResult>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<UnsubscribeResult>;
+    getPlain(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<Uint8Array>>;
+    destroy(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<VoidResult>;
+}
+interface SerdeGatewayReturn<O, T> {
+    readonly op: O;
+    readonly value?: T;
+    readonly stop?: boolean;
+}
+interface SerdeGatewayBuildUrlOp {
+    readonly url: URI;
+    readonly key: string;
+}
+type SerdeGatewayBuildUrlReturn = SerdeGatewayReturn<SerdeGatewayBuildUrlOp, Result<URI>>;
+interface SerdeGatewayStartOp {
+    readonly url: URI;
+}
+type SerdeGatewayStartReturn = SerdeGatewayReturn<SerdeGatewayStartOp, Result<URI>>;
+interface SerdeGatewayCloseOp {
+    readonly url: URI;
+}
+type SerdeGatewayCloseReturn = SerdeGatewayReturn<SerdeGatewayCloseOp, VoidResult>;
+interface SerdeGatewayDestroyOp {
+    readonly url: URI;
+}
+type SerdeGatewayDestroyReturn = SerdeGatewayReturn<SerdeGatewayDestroyOp, VoidResult>;
+interface SerdeGatewayPutOp<T> {
+    readonly url: URI;
+    readonly body: FPEnvelope<T>;
+}
+type SerdeGatewayPutReturn<T> = SerdeGatewayReturn<SerdeGatewayPutOp<T>, VoidResult>;
+interface SerdeGatewayGetOp {
+    readonly url: URI;
+}
+type SerdeGatewayGetReturn<S> = SerdeGatewayReturn<SerdeGatewayGetOp, SerdeGetResult<S>>;
+interface SerdeGatewayDeleteOp {
+    readonly url: URI;
+}
+type SerdeGatewayDeleteReturn = SerdeGatewayReturn<SerdeGatewayDeleteOp, VoidResult>;
+interface SerdeGatewaySubscribeOp {
+    readonly url: URI;
+    readonly callback: (meta: FPEnvelopeMeta) => Promise<void>;
+}
+type SerdeGatewaySubscribeReturn = SerdeGatewayReturn<SerdeGatewaySubscribeOp, UnsubscribeResult>;
+interface SerdeGatewayInterceptor {
+    buildUrl(ctx: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<SerdeGatewayBuildUrlReturn>>;
+    start(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<SerdeGatewayStartReturn>>;
+    close(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<SerdeGatewayCloseReturn>>;
+    delete(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<SerdeGatewayDeleteReturn>>;
+    destroy(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<SerdeGatewayDestroyReturn>>;
+    put<T>(ctx: SerdeGatewayCtx, url: URI, body: FPEnvelope<T>): Promise<Result<SerdeGatewayPutReturn<T>>>;
+    get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayGetReturn<S>>>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<Result<SerdeGatewaySubscribeReturn>>;
+}
+
+declare class Context {
+    private ctx;
+    set<T>(key: string, value: T): void;
+    get<T>(key: string): T | undefined;
+    delete(key: string): void;
+}
+
+interface BlockEncoder<Code extends number, T> {
+    readonly name: string;
+    readonly code: Code;
+    bytesToHash?(data: T): ByteView<unknown>;
+    encode(data: T): ByteView<T>;
+}
+interface AsyncBlockEncoder<Code extends number, T> {
+    readonly name: string;
+    readonly code: Code;
+    bytesToHash?(data: T): Promise<ByteView<unknown>>;
+    encode(data: T): PromiseLike<ByteView<T>>;
+}
+interface BlockDecoder<Code extends number, T> {
+    readonly code: Code;
+    valueToHashBytes?(value: T): ByteView<unknown>;
+    decode(bytes: ByteView<unknown>): T;
+}
+interface AsyncBlockDecoder<Code extends number, T> {
+    readonly code: Code;
+    valueToHashBytes?(value: T): Promise<ByteView<unknown>>;
+    decode(bytes: ByteView<unknown>): PromiseLike<T>;
+}
+interface BlockCodec<Code extends number, E, D> extends BlockEncoder<Code, E>, BlockDecoder<Code, D> {
+}
+interface AsyncBlockCodec<Code extends number, E, D> extends AsyncBlockEncoder<Code, E>, AsyncBlockDecoder<Code, D> {
+}
+
+declare const codecInterface_ArrayBufferView: typeof ArrayBufferView;
+type codecInterface_AsyncBlockCodec<Code extends number, E, D> = AsyncBlockCodec<Code, E, D>;
+type codecInterface_AsyncBlockDecoder<Code extends number, T> = AsyncBlockDecoder<Code, T>;
+type codecInterface_AsyncBlockEncoder<Code extends number, T> = AsyncBlockEncoder<Code, T>;
+type codecInterface_BlockCodec<Code extends number, E, D> = BlockCodec<Code, E, D>;
+type codecInterface_BlockDecoder<Code extends number, T> = BlockDecoder<Code, T>;
+type codecInterface_BlockEncoder<Code extends number, T> = BlockEncoder<Code, T>;
+declare const codecInterface_ByteView: typeof ByteView;
+declare namespace codecInterface {
+  export { codecInterface_ArrayBufferView as ArrayBufferView, type codecInterface_AsyncBlockCodec as AsyncBlockCodec, type codecInterface_AsyncBlockDecoder as AsyncBlockDecoder, type codecInterface_AsyncBlockEncoder as AsyncBlockEncoder, type codecInterface_BlockCodec as BlockCodec, type codecInterface_BlockDecoder as BlockDecoder, type codecInterface_BlockEncoder as BlockEncoder, codecInterface_ByteView as ByteView };
+}
+
+type AnyLink = Link<unknown, number, number, Version>;
+type CarGroup = AnyLink[];
+type FroozenCarLog = CarGroup[];
+declare class CarLog {
+    readonly _logs: CarGroup[];
+    get length(): number;
+    last(): AnyLink[];
+    xunshift(logs: CarGroup): void;
+    update(logs: FroozenCarLog): void;
+    asArray(): FroozenCarLog;
+}
+type AnyAnyLink = Link<unknown, number, number, Version>;
+type AnyLinkFn = (cid: AnyLink) => Promise<AnyBlock | undefined>;
+interface AnyBlock {
+    readonly cid: Link<unknown, number, number, Version>;
+    readonly bytes: Uint8Array;
+}
+interface CIDBlock {
+    readonly cid: CID<unknown, number, number, Version>;
+    readonly bytes: Uint8Array;
+}
+declare function toCIDBlock(block: AnyBlock): CIDBlock;
+interface AnyAnyBlock {
+    readonly cid: AnyAnyLink;
+    readonly bytes: Uint8Array;
+}
+interface IvKeyIdData {
+    readonly iv: Uint8Array;
+    readonly keyId: Uint8Array;
+    readonly data: Uint8Array;
+}
+interface IvAndKeyAndBytes {
+    readonly bytes: Uint8Array;
+    readonly key: CTCryptoKey;
+    readonly iv: Uint8Array;
+}
+interface BytesAndKeyWithIv {
+    readonly bytes: Uint8Array;
+    readonly key: CTCryptoKey;
+    readonly iv?: Uint8Array;
+}
+interface AnyDecodedBlock {
+    readonly cid: AnyLink;
+    readonly bytes: Uint8Array;
+    readonly value: Uint8Array;
+}
+interface CarMakeable {
+    entries(): AsyncIterable<AnyBlock>;
+    get(cid: AnyLink): Promise<AnyBlock | undefined>;
+}
+interface CarHeader<T> {
+    readonly cars: FroozenCarLog;
+    readonly compact: FroozenCarLog;
+    readonly meta: T;
+}
+interface TransactionWrapper<M extends TransactionMeta> {
+    meta: M;
+    cars?: CarGroup;
+    t: CarTransaction;
+}
+type TransactionMeta = unknown;
+interface EncryptedBlock {
+    readonly value: IvAndKeyAndBytes;
+}
+interface KeyMaterial {
+    readonly key: Uint8Array;
+    readonly keyStr: string;
+}
+interface KeyWithFingerPrint {
+    readonly fingerPrint: string;
+    readonly key: CTCryptoKey;
+    extract(): Promise<KeyMaterial>;
+}
+interface CodecOpts {
+    readonly ivCalc: "random" | "hash";
+    readonly noIVVerify: boolean;
+}
+interface KeyUpsertResult {
+    readonly modified: boolean;
+    readonly kfp: KeyWithFingerPrint;
+}
+interface KeysByFingerprint {
+    readonly id: string;
+    readonly name: string;
+    get(fingerPrint?: Uint8Array | string): Promise<KeyWithFingerPrint | undefined>;
+    upsert(key: string | Uint8Array, def?: boolean): Promise<Result<KeyUpsertResult>>;
+    asKeysItem(): Promise<KeysItem>;
+}
+interface CryptoAction {
+    readonly ivLength: number;
+    readonly logger: Logger;
+    readonly crypto: CryptoRuntime;
+    readonly url: URI;
+    readonly key: KeysByFingerprint;
+    algo(iv?: Uint8Array): {
+        name: string;
+        iv: Uint8Array;
+        tagLength: number;
+    };
+    codec(iv?: Uint8Array, codecOpts?: Partial<CodecOpts>): AsyncBlockCodec<24, Uint8Array, IvKeyIdData>;
+    _decrypt(data: IvAndKeyAndBytes): Promise<Uint8Array>;
+    _encrypt(data: BytesAndKeyWithIv): Promise<Uint8Array>;
+}
+interface StoreFactory {
+    encodeFile?: (blob: Blob) => Promise<{
+        cid: AnyLink;
+        blocks: AnyBlock[];
+    }>;
+    decodeFile?: (blocks: unknown, cid: AnyLink, meta: DocFileMeta) => Promise<File>;
+}
+interface StoreUrls {
+    readonly meta: CoerceURI;
+    readonly car: CoerceURI;
+    readonly file: CoerceURI;
+    readonly wal: CoerceURI;
+}
+interface StoreEnDeFile {
+    readonly encodeFile: (blob: Blob) => Promise<{
+        cid: AnyLink;
+        blocks: AnyBlock[];
+    }>;
+    readonly decodeFile: (blocks: unknown, cid: AnyLink, meta: DocFileMeta) => Promise<Result<File>>;
+}
+interface StoreUrlsOpts {
+    readonly base?: CoerceURI;
+    readonly data?: Partial<StoreUrls>;
+    readonly idx?: Partial<StoreUrls>;
+}
+interface StoreURIs {
+    readonly meta: URI;
+    readonly car: URI;
+    readonly file: URI;
+    readonly wal: URI;
+}
+interface StoreURIRuntime {
+    readonly data: StoreURIs;
+    readonly idx: StoreURIs;
+}
+interface UrlAndInterceptor {
+    readonly url: URI;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+}
+interface StoreFactoryItem {
+    readonly byStore: GatewayUrls;
+    readonly loader: Loadable;
+}
+interface StoreRuntime {
+    makeStores(sfi: StoreFactoryItem): Promise<DataAndMetaAndWalStore>;
+    encodeFile(blob: Blob): Promise<{
+        cid: AnyLink;
+        blocks: AnyBlock[];
+    }>;
+    decodeFile(blocks: unknown, cid: AnyLink, meta: DocFileMeta): Promise<Result<File>>;
+}
+interface CommitOpts {
+    readonly noLoader?: boolean;
+    readonly compact?: boolean;
+}
+interface WriteableDataAndMetaStore {
+    file: FileStore;
+    car: CarStore;
+    meta: MetaStore;
+}
+type DataAndMetaStore = Readonly<WriteableDataAndMetaStore>;
+interface WriteableDataAndMetaAndWalStore extends WriteableDataAndMetaStore {
+    wal?: WALStore;
+}
+type DataAndMetaAndWalStore = Readonly<WriteableDataAndMetaAndWalStore>;
+type LocalDataAndMetaAndWalStore = Readonly<Omit<WriteableDataAndMetaAndWalStore, "wal">> & {
+    readonly wal: WALStore;
+};
+interface DbMeta {
+    readonly cars: CarGroup;
+}
+type LoadHandler = (dbMetas: DbMeta[]) => Promise<void>;
+interface RefLoadable {
+    readonly loader: Loadable;
+}
+interface RefBlockstore {
+    readonly blockstore: RefLoadable;
+}
+interface Connection {
+    loaded(): Future<void>;
+    readonly context: Context;
+    connectStorage(ref: RefLoadable | RefBlockstore): void;
+}
+interface BaseStore {
+    readonly storeType: StoreType;
+    readonly realGateway: SerdeGateway;
+    readonly logger: Logger;
+    url(): URI;
+    keyedCrypto(): Promise<CryptoAction>;
+    close(): Promise<Result<void>>;
+    destroy(): Promise<Result<void>>;
+    readonly ready?: () => Promise<void>;
+    start(dam: DataAndMetaStore): Promise<Result<URI>>;
+}
+interface DbMetaEvent {
+    readonly eventCid: CarClockLink;
+    readonly parents: CarClockHead;
+    readonly dbMeta: DbMeta;
+}
+declare function DbMetaEventEqual(a: DbMetaEvent, b: DbMetaEvent): boolean;
+declare function DbMetaEventsEqual(a: DbMetaEvent[], b: DbMetaEvent[]): boolean;
+interface MetaStore extends BaseStore {
+    readonly storeType: "meta";
+    load(branch?: string): Promise<DbMeta[] | Falsy>;
+    save(meta: DbMeta, branch?: string): Promise<Result<void>>;
+}
+interface DataSaveOpts {
+    readonly public: boolean;
+}
+interface CarStore extends BaseStore {
+    readonly storeType: "car";
+    load(cid: AnyLink): Promise<AnyBlock>;
+    save(car: AnyBlock, opts?: DataSaveOpts): Promise<void>;
+    remove(cid: AnyLink): Promise<Result<void>>;
+}
+interface FileStore extends BaseStore {
+    readonly storeType: "file";
+    load(cid: AnyLink): Promise<AnyBlock>;
+    save(car: AnyBlock, opts?: DataSaveOpts): Promise<void>;
+    remove(cid: AnyLink): Promise<Result<void>>;
+}
+interface WALState {
+    readonly operations: DbMeta[];
+    readonly noLoaderOps: DbMeta[];
+    readonly fileOperations: {
+        readonly cid: AnyLink;
+        readonly public: boolean;
+    }[];
+}
+interface WALStore extends BaseStore {
+    readonly storeType: "wal";
+    ready(): Promise<void>;
+    readonly processing?: Promise<void> | undefined;
+    readonly processQueue: CommitQueue<void>;
+    process(): Promise<void>;
+    enqueue(dbMeta: DbMeta, opts: CommitOpts): Promise<void>;
+    enqueueFile(fileCid: AnyLink): Promise<void>;
+    load(): Promise<WALState | Falsy>;
+    save(state: WALState): Promise<void>;
+}
+type CompactFetcher = BlockFetcher & {
+    readonly loggedBlocks: CarTransaction;
+};
+type CompactFn = (blocks: CompactFetcher) => Promise<TransactionMeta>;
+interface StoreRuntimeUrls {
+    readonly meta: URI;
+    readonly data: URI;
+    readonly wal: URI;
+}
+interface BlockstoreParams {
+    readonly logger: Logger;
+    readonly applyMeta: (meta: TransactionMeta, snap?: boolean) => Promise<void>;
+    readonly compact: CompactFn;
+    readonly autoCompact: number;
+    readonly crypto: CryptoRuntime;
+    readonly public: boolean;
+    readonly meta: DbMeta;
+    readonly threshold: number;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+    readonly storeEnDeFile: Partial<StoreEnDeFile>;
+    readonly keyBag: KeyBagRuntime;
+    readonly storeUrls: StoreURIs;
+    readonly storeRuntime: StoreRuntime;
+    readonly taskManager: TaskManagerParams;
+}
+type BlockstoreOpts = Partial<BlockstoreParams> & {
+    readonly keyBag: KeyBagRuntime;
+    readonly storeUrls: StoreURIs;
+    readonly storeRuntime: StoreRuntime;
+};
+interface BlockstoreRuntime {
+    readonly logger: Logger;
+    readonly applyMeta: (meta: TransactionMeta, snap?: boolean) => Promise<void>;
+    readonly compact: CompactFn;
+    readonly autoCompact: number;
+    readonly crypto: CryptoRuntime;
+    readonly storeRuntime: StoreRuntime;
+    readonly keyBag: KeyBagRuntime;
+    readonly storeUrls: StoreURIs;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+    readonly taskManager: TaskManagerParams;
+    readonly meta?: DbMeta;
+    readonly threshold: number;
+}
+type LocalActiveStore = Omit<ActiveStore, "active"> & {
+    readonly active: LocalDataAndMetaAndWalStore;
+};
+interface AttachedStores {
+    local(): LocalActiveStore;
+    forRemotes(actionFn: (store: ActiveStore) => Promise<unknown>): Promise<void>;
+    remotes(): ActiveStore[];
+    activate(store: DataAndMetaStore | CoerceURI): ActiveStore;
+    attach(attached: Attachable): Promise<Attached>;
+    detach(): Promise<void>;
+}
+interface BaseAttachedStores {
+    local(): BaseStore;
+    remotes(): BaseStore[];
+}
+interface CarAttachedStores extends BaseAttachedStores {
+    local(): CarStore;
+    remotes(): CarStore[];
+}
+declare abstract class BaseActiveStore {
+    abstract readonly ref: ActiveStore;
+    abstract readonly active: BaseStore;
+    abstract local(): BaseStore;
+    abstract remotes(): BaseStore[];
+    protected abstract readonly xattached: BaseAttachedStores;
+}
+interface FileAttachedStores extends BaseAttachedStores {
+    local(): FileStore;
+    remotes(): FileStore[];
+}
+declare abstract class CarActiveStore extends BaseActiveStore {
+    protected abstract readonly xattached: CarAttachedStores;
+    abstract local(): CarStore;
+    abstract remotes(): CarStore[];
+}
+declare abstract class FileActiveStore extends BaseActiveStore {
+    protected abstract readonly xattached: FileAttachedStores;
+    abstract local(): FileStore;
+    abstract remotes(): FileStore[];
+}
+type CIDActiveStore = CarActiveStore | FileActiveStore;
+interface MetaAttachedStores extends BaseAttachedStores {
+    local(): MetaStore;
+    remotes(): MetaStore[];
+}
+declare abstract class MetaActiveStore extends BaseActiveStore {
+    protected abstract readonly xattached: MetaAttachedStores;
+    abstract local(): MetaStore;
+    abstract remotes(): MetaStore[];
+}
+interface WALAttachedStores extends BaseAttachedStores {
+    local(): WALStore;
+    remotes(): WALStore[];
+}
+declare abstract class WALActiveStore extends BaseActiveStore {
+    protected abstract readonly xattached: WALAttachedStores;
+    abstract local(): WALStore;
+    abstract remotes(): WALStore[];
+}
+interface ActiveStore {
+    readonly active: DataAndMetaAndWalStore;
+    baseStores(): BaseStore[];
+    carStore(): CarActiveStore;
+    fileStore(): FileActiveStore;
+    metaStore(): MetaActiveStore;
+    walStore(): WALActiveStore;
+    local(): LocalActiveStore;
+    remotes(): ActiveStore[];
+    readonly xattached: AttachedStores;
+}
+interface CarCacheItem {
+    readonly type: "car" | "block";
+    readonly cid: AnyLink;
+    readonly blocks: AnyBlock[];
+    readonly roots: CID[];
+}
+interface Loadable {
+    readonly sthis: SuperThis;
+    readonly ebOpts: BlockstoreRuntime;
+    readonly carLog: CarLog;
+    readonly attachedStores: AttachedStores;
+    attach(attached: Attachable): Promise<Attached>;
+    readonly taskManager: TaskManager;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    keyBag(): Promise<KeyBag>;
+    handleDbMetasFromStore(metas: DbMeta[], store: ActiveStore): Promise<void>;
+    commit<T = TransactionMeta>(t: CarTransaction, done: T, opts: CommitOpts): Promise<CarGroup>;
+    destroy(): Promise<void>;
+    getBlock(cid: AnyLink, store: ActiveStore): Promise<AnyBlock | Falsy>;
+    loadFileCar(cid: AnyLink, store: ActiveStore): Promise<CarCacheItem>;
+    loadCar(cid: AnyLink, store: ActiveStore): Promise<CarCacheItem>;
+    commitFiles(t: CarTransaction, done: TransactionMeta): Promise<CarGroup>;
+    entries(cache?: boolean): AsyncIterableIterator<AnyBlock>;
+}
+interface DbMetaBinary {
+    readonly dbMeta: Uint8Array;
+}
+type DbMetaEventBlock = EventBlock<DbMetaBinary>;
+type CarClockLink = Link<DbMetaEventBlock, number, number, Version>;
+type CarClockHead = CarClockLink[];
+
+declare class PassThroughGateway implements SerdeGatewayInterceptor {
+    buildUrl(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<SerdeGatewayBuildUrlReturn>>;
+    start(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayStartReturn>>;
+    close(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayCloseReturn>>;
+    delete(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayDeleteReturn>>;
+    destroy(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayDestroyReturn>>;
+    put<T>(ctx: SerdeGatewayCtx, url: URI, body: FPEnvelope<T>): Promise<Result<SerdeGatewayPutReturn<T>>>;
+    get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayGetReturn<S>>>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<Result<SerdeGatewaySubscribeReturn>>;
+}
+declare class InterceptorGateway implements SerdeGateway {
+    readonly innerGW: SerdeGateway;
+    readonly interceptor: SerdeGatewayInterceptor;
+    constructor(sthis: SuperThis, innerGW: SerdeGateway, interceptor: SerdeGatewayInterceptor | undefined);
+    buildUrl(ctx: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<URI>>;
+    destroy(ctx: SerdeGatewayCtx, iurl: URI): Promise<Result<void>>;
+    start(ctx: SerdeGatewayCtx, url: URI): Promise<Result<URI>>;
+    close(ctx: SerdeGatewayCtx, url: URI): Promise<VoidResult>;
+    put<T>(ctx: SerdeGatewayCtx, url: URI, fpEnv: FPEnvelope<T>): Promise<VoidResult>;
+    get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<SerdeGetResult<S>>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (msg: FPEnvelopeMeta) => Promise<void>): Promise<UnsubscribeResult>;
+    delete(ctx: SerdeGatewayCtx, url: URI): Promise<VoidResult>;
+    getPlain(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<Uint8Array>>;
+}
+
+declare function getInterceptableGateway(ctx: SerdeGatewayCtx, url: URI, opt: {
+    gatewayInterceptor?: SerdeGatewayInterceptor;
+}): Promise<Result<InterceptorGateway>>;
+declare function ensureStoreEnDeFile(ende?: Partial<StoreEnDeFile>): StoreEnDeFile;
+declare function toStoreRuntime(sthis: SuperThis, endeOpts?: Partial<StoreEnDeFile>): StoreRuntime;
+
+interface GatewayOpts {
+    readonly gateway: Gateway;
+}
+type GetResult = Result<Uint8Array, NotFoundError | Error>;
+interface Gateway {
+    buildUrl(baseUrl: URI, key: string, sthis: SuperThis): Promise<Result<URI>>;
+    start(baseUrl: URI, sthis: SuperThis): Promise<Result<URI>>;
+    close(baseUrl: URI, sthis: SuperThis): Promise<VoidResult>;
+    destroy(baseUrl: URI, sthis: SuperThis): Promise<VoidResult>;
+    put(url: URI, body: Uint8Array, sthis: SuperThis): Promise<VoidResult>;
+    get(url: URI, sthis: SuperThis): Promise<GetResult>;
+    delete(url: URI, sthis: SuperThis): Promise<VoidResult>;
+    subscribe?(url: URI, callback: (meta: Uint8Array) => void, sthis: SuperThis): Promise<UnsubscribeResult>;
+    getPlain(url: URI, key: string, sthis: SuperThis): Promise<Result<Uint8Array>>;
+}
+
+declare function createDbMetaEvent(sthis: SuperThis, dbMeta: DbMeta, parents: CarClockHead): Promise<DbMetaEvent>;
+
+interface SerdeGatewayFactoryItem {
+    readonly protocol: string;
+    readonly isDefault?: boolean;
+    defaultURI(sthis: SuperThis): URI;
+    serdegateway(sthis: SuperThis): Promise<SerdeGateway>;
+}
+declare function getDefaultURI(sthis: SuperThis, protocol?: string): URI;
+interface SerdeOrGatewayFactoryItem {
+    readonly protocol: string;
+    readonly isDefault?: boolean;
+    readonly defaultURI: (sthis: SuperThis) => URI;
+    readonly serdegateway?: (sthis: SuperThis) => Promise<SerdeGateway>;
+    readonly gateway?: (sthis: SuperThis) => Promise<Gateway>;
+}
+declare function registerStoreProtocol(item: SerdeOrGatewayFactoryItem): () => void;
+declare function getGatewayFactoryItem(protocol: string): SerdeGatewayFactoryItem | undefined;
+declare function defaultGatewayFactoryItem(): SerdeGatewayFactoryItem;
+
+declare function createAttachedStores(urlOrGup: CoerceURI | GatewayUrlsParam, arOrLoadable: AttachedStores | Loadable, name?: string): Promise<Attached>;
+declare class AttachedRemotesImpl implements AttachedStores {
+    private readonly _remotes;
+    readonly loadable: Loadable;
+    _local?: Attached;
+    constructor(loadable: Loadable);
+    forRemotes(action: (store: ActiveStore) => Promise<unknown>): Promise<void>;
+    remotes(): ActiveStore[];
+    local(): LocalActiveStore;
+    activate(store: DataAndMetaStore | CoerceURI): ActiveStore;
+    detach(): Promise<void>;
+    attach(attached: Attachable): Promise<Attached>;
+}
+
+type URIMapper = (uri: URI) => Promisable<URI>;
+declare class URIInterceptor extends PassThroughGateway {
+    #private;
+    static withMapper(mapper: URIMapper): URIInterceptor;
+    addMapper(mapper: URIMapper): URIInterceptor;
+    buildUrl(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<SerdeGatewayBuildUrlReturn>>;
+    start(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayStartReturn>>;
+    close(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayCloseReturn>>;
+    delete(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayDeleteReturn>>;
+    destroy(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayDestroyReturn>>;
+    put<T>(ctx: SerdeGatewayCtx, url: URI, body: FPEnvelope<T>): Promise<Result<SerdeGatewayPutReturn<T>>>;
+    get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<Result<SerdeGatewayGetReturn<S>>>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<Result<SerdeGatewaySubscribeReturn>>;
+}
+
+declare class Loader implements Loadable {
+    readonly ebOpts: BlockstoreRuntime;
+    readonly logger: Logger;
+    readonly commitQueue: CommitQueue<CarGroup>;
+    isCompacting: boolean;
+    private readonly cidCache;
+    private readonly maxConcurrentCarReader;
+    private readonly maxConcurrentWrite;
+    readonly seenCompacted: LRUSet<string>;
+    readonly sthis: SuperThis;
+    readonly taskManager: TaskManager;
+    readonly carLog: CarLog;
+    readonly attachedStores: AttachedStores;
+    attach(attached: Attachable): Promise<Attached>;
+    private seenMeta;
+    keyBag(): Promise<KeyBag>;
+    private readonly onceReady;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    constructor(sthis: SuperThis, ebOpts: BlockstoreOpts);
+    handleDbMetasFromStore(metas: DbMeta[], activeStore: ActiveStore): Promise<void>;
+    mergeDbMetaIntoClock(meta: DbMeta, activeStore: ActiveStore): Promise<void>;
+    loadCarHeaderFromMeta<T>(dbm: DbMeta, astore: ActiveStore): Promise<CarHeader<T>>;
+    commitFiles(t: CarTransaction, done: TransactionMeta): Promise<CarGroup>;
+    loadFileCar(cid: AnyLink, store: ActiveStore): Promise<CarCacheItem>;
+    commit<T = TransactionMeta>(t: CarTransaction, done: T, opts?: CommitOpts): Promise<CarGroup>;
+    updateCarLog<T>(cids: CarGroup, cHeader: CarHeader<T>, compact: boolean): Promise<void>;
+    cacheTransaction(t: CarTransaction): Promise<void>;
+    removeCidsForCompact(cid: AnyLink, store: ActiveStore): Promise<void>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+    getBlock(cid: AnyLink, store: ActiveStore): Promise<AnyBlock | Falsy>;
+    loadCar(cid: AnyLink, store: ActiveStore): Promise<CarCacheItem>;
+    private makeDecoderAndCarReader;
+    protected storesLoadCar(carCid: AnyLink, store: CIDActiveStore): Promise<CarCacheItem>;
+    protected getMoreReaders(cids: AnyLink[], store: ActiveStore): Promise<void>;
+}
+
+declare function parseCarFile<T>(reader: CarCacheItem, logger: Logger): Promise<CarHeader<T>>;
+
+type index$8_ActiveStore = ActiveStore;
+type index$8_AnyAnyBlock = AnyAnyBlock;
+type index$8_AnyAnyLink = AnyAnyLink;
+type index$8_AnyBlock = AnyBlock;
+type index$8_AnyDecodedBlock = AnyDecodedBlock;
+type index$8_AnyLink = AnyLink;
+type index$8_AnyLinkFn = AnyLinkFn;
+type index$8_AttachedRemotesImpl = AttachedRemotesImpl;
+declare const index$8_AttachedRemotesImpl: typeof AttachedRemotesImpl;
+type index$8_AttachedStores = AttachedStores;
+type index$8_BaseActiveStore = BaseActiveStore;
+declare const index$8_BaseActiveStore: typeof BaseActiveStore;
+type index$8_BaseAttachedStores = BaseAttachedStores;
+type index$8_BaseBlockstoreImpl = BaseBlockstoreImpl;
+declare const index$8_BaseBlockstoreImpl: typeof BaseBlockstoreImpl;
+type index$8_BaseStore = BaseStore;
+type index$8_BlockFetcher = BlockFetcher;
+type index$8_BlockstoreOpts = BlockstoreOpts;
+type index$8_BlockstoreParams = BlockstoreParams;
+type index$8_BlockstoreRuntime = BlockstoreRuntime;
+type index$8_BytesAndKeyWithIv = BytesAndKeyWithIv;
+type index$8_CIDActiveStore = CIDActiveStore;
+type index$8_CIDBlock = CIDBlock;
+declare const index$8_Car2FPMsg: typeof Car2FPMsg;
+type index$8_CarActiveStore = CarActiveStore;
+declare const index$8_CarActiveStore: typeof CarActiveStore;
+type index$8_CarAttachedStores = CarAttachedStores;
+type index$8_CarCacheItem = CarCacheItem;
+type index$8_CarClockHead = CarClockHead;
+type index$8_CarClockLink = CarClockLink;
+type index$8_CarGroup = CarGroup;
+type index$8_CarHeader<T> = CarHeader<T>;
+type index$8_CarLog = CarLog;
+declare const index$8_CarLog: typeof CarLog;
+type index$8_CarMakeable = CarMakeable;
+type index$8_CarStore = CarStore;
+type index$8_CarTransactionImpl = CarTransactionImpl;
+declare const index$8_CarTransactionImpl: typeof CarTransactionImpl;
+type index$8_CarTransactionOpts = CarTransactionOpts;
+type index$8_CodecOpts = CodecOpts;
+type index$8_CommitOpts = CommitOpts;
+type index$8_CompactFetcher = CompactFetcher;
+type index$8_CompactFn = CompactFn;
+type index$8_CompactionFetcher = CompactionFetcher;
+declare const index$8_CompactionFetcher: typeof CompactionFetcher;
+type index$8_Connection = Connection;
+type index$8_CryptoAction = CryptoAction;
+type index$8_DataAndMetaAndWalStore = DataAndMetaAndWalStore;
+type index$8_DataAndMetaStore = DataAndMetaStore;
+type index$8_DataSaveOpts = DataSaveOpts;
+type index$8_DbMeta = DbMeta;
+type index$8_DbMetaBinary = DbMetaBinary;
+type index$8_DbMetaEvent = DbMetaEvent;
+type index$8_DbMetaEventBlock = DbMetaEventBlock;
+declare const index$8_DbMetaEventEqual: typeof DbMetaEventEqual;
+declare const index$8_DbMetaEventsEqual: typeof DbMetaEventsEqual;
+type index$8_EncryptedBlock = EncryptedBlock;
+type index$8_EncryptedBlockstore = EncryptedBlockstore;
+declare const index$8_EncryptedBlockstore: typeof EncryptedBlockstore;
+type index$8_FPEnvelope<T> = FPEnvelope<T>;
+type index$8_FPEnvelopeCar = FPEnvelopeCar;
+type index$8_FPEnvelopeFile = FPEnvelopeFile;
+type index$8_FPEnvelopeMeta = FPEnvelopeMeta;
+type index$8_FPEnvelopeType = FPEnvelopeType;
+declare const index$8_FPEnvelopeTypes: typeof FPEnvelopeTypes;
+type index$8_FPEnvelopeWAL = FPEnvelopeWAL;
+type index$8_FPWALCarsOps = FPWALCarsOps;
+declare const index$8_File2FPMsg: typeof File2FPMsg;
+type index$8_FileActiveStore = FileActiveStore;
+declare const index$8_FileActiveStore: typeof FileActiveStore;
+type index$8_FileAttachedStores = FileAttachedStores;
+type index$8_FileStore = FileStore;
+type index$8_FroozenCarLog = FroozenCarLog;
+type index$8_Gateway = Gateway;
+type index$8_GatewayOpts = GatewayOpts;
+type index$8_GetResult = GetResult;
+type index$8_InterceptorGateway = InterceptorGateway;
+declare const index$8_InterceptorGateway: typeof InterceptorGateway;
+type index$8_IvAndKeyAndBytes = IvAndKeyAndBytes;
+type index$8_IvKeyIdData = IvKeyIdData;
+type index$8_KeyMaterial = KeyMaterial;
+type index$8_KeyUpsertResult = KeyUpsertResult;
+type index$8_KeyWithFingerPrint = KeyWithFingerPrint;
+type index$8_KeysByFingerprint = KeysByFingerprint;
+type index$8_LoadHandler = LoadHandler;
+type index$8_Loadable = Loadable;
+type index$8_Loader = Loader;
+declare const index$8_Loader: typeof Loader;
+type index$8_LocalActiveStore = LocalActiveStore;
+type index$8_LocalDataAndMetaAndWalStore = LocalDataAndMetaAndWalStore;
+type index$8_MetaActiveStore = MetaActiveStore;
+declare const index$8_MetaActiveStore: typeof MetaActiveStore;
+type index$8_MetaAttachedStores = MetaAttachedStores;
+type index$8_MetaStore = MetaStore;
+type index$8_PassThroughGateway = PassThroughGateway;
+declare const index$8_PassThroughGateway: typeof PassThroughGateway;
+type index$8_RefBlockstore = RefBlockstore;
+type index$8_RefLoadable = RefLoadable;
+type index$8_SerdeGateway = SerdeGateway;
+type index$8_SerdeGatewayBuildUrlOp = SerdeGatewayBuildUrlOp;
+type index$8_SerdeGatewayBuildUrlReturn = SerdeGatewayBuildUrlReturn;
+type index$8_SerdeGatewayCloseOp = SerdeGatewayCloseOp;
+type index$8_SerdeGatewayCloseReturn = SerdeGatewayCloseReturn;
+type index$8_SerdeGatewayCtx = SerdeGatewayCtx;
+type index$8_SerdeGatewayDeleteOp = SerdeGatewayDeleteOp;
+type index$8_SerdeGatewayDeleteReturn = SerdeGatewayDeleteReturn;
+type index$8_SerdeGatewayDestroyOp = SerdeGatewayDestroyOp;
+type index$8_SerdeGatewayDestroyReturn = SerdeGatewayDestroyReturn;
+type index$8_SerdeGatewayFactoryItem = SerdeGatewayFactoryItem;
+type index$8_SerdeGatewayGetOp = SerdeGatewayGetOp;
+type index$8_SerdeGatewayGetReturn<S> = SerdeGatewayGetReturn<S>;
+type index$8_SerdeGatewayInterceptor = SerdeGatewayInterceptor;
+type index$8_SerdeGatewayOpts = SerdeGatewayOpts;
+type index$8_SerdeGatewayPutOp<T> = SerdeGatewayPutOp<T>;
+type index$8_SerdeGatewayPutReturn<T> = SerdeGatewayPutReturn<T>;
+type index$8_SerdeGatewayReturn<O, T> = SerdeGatewayReturn<O, T>;
+type index$8_SerdeGatewayStartOp = SerdeGatewayStartOp;
+type index$8_SerdeGatewayStartReturn = SerdeGatewayStartReturn;
+type index$8_SerdeGatewaySubscribeOp = SerdeGatewaySubscribeOp;
+type index$8_SerdeGatewaySubscribeReturn = SerdeGatewaySubscribeReturn;
+type index$8_SerdeGetResult<S> = SerdeGetResult<S>;
+type index$8_SerdeOrGatewayFactoryItem = SerdeOrGatewayFactoryItem;
+type index$8_StoreEnDeFile = StoreEnDeFile;
+type index$8_StoreFactory = StoreFactory;
+type index$8_StoreFactoryItem = StoreFactoryItem;
+type index$8_StoreRuntime = StoreRuntime;
+type index$8_StoreRuntimeUrls = StoreRuntimeUrls;
+type index$8_StoreURIRuntime = StoreURIRuntime;
+type index$8_StoreURIs = StoreURIs;
+type index$8_StoreUrls = StoreUrls;
+type index$8_StoreUrlsOpts = StoreUrlsOpts;
+type index$8_TaskManager = TaskManager;
+declare const index$8_TaskManager: typeof TaskManager;
+type index$8_TaskManagerParams = TaskManagerParams;
+type index$8_TransactionMeta = TransactionMeta;
+type index$8_TransactionWrapper<M extends TransactionMeta> = TransactionWrapper<M>;
+type index$8_URIInterceptor = URIInterceptor;
+declare const index$8_URIInterceptor: typeof URIInterceptor;
+type index$8_URIMapper = URIMapper;
+type index$8_UnsubscribeResult = UnsubscribeResult;
+type index$8_UrlAndInterceptor = UrlAndInterceptor;
+type index$8_VoidResult = VoidResult;
+type index$8_WALActiveStore = WALActiveStore;
+declare const index$8_WALActiveStore: typeof WALActiveStore;
+type index$8_WALAttachedStores = WALAttachedStores;
+type index$8_WALState = WALState;
+type index$8_WALStore = WALStore;
+type index$8_WriteableDataAndMetaAndWalStore = WriteableDataAndMetaAndWalStore;
+type index$8_WriteableDataAndMetaStore = WriteableDataAndMetaStore;
+declare const index$8_createAttachedStores: typeof createAttachedStores;
+declare const index$8_createDbMetaEvent: typeof createDbMetaEvent;
+declare const index$8_defaultGatewayFactoryItem: typeof defaultGatewayFactoryItem;
+declare const index$8_ensureStoreEnDeFile: typeof ensureStoreEnDeFile;
+declare const index$8_getDefaultURI: typeof getDefaultURI;
+declare const index$8_getGatewayFactoryItem: typeof getGatewayFactoryItem;
+declare const index$8_getInterceptableGateway: typeof getInterceptableGateway;
+declare const index$8_parseCarFile: typeof parseCarFile;
+declare const index$8_registerStoreProtocol: typeof registerStoreProtocol;
+declare const index$8_toCIDBlock: typeof toCIDBlock;
+declare const index$8_toStoreRuntime: typeof toStoreRuntime;
+declare namespace index$8 {
+  export { type index$8_ActiveStore as ActiveStore, type index$8_AnyAnyBlock as AnyAnyBlock, type index$8_AnyAnyLink as AnyAnyLink, type index$8_AnyBlock as AnyBlock, type index$8_AnyDecodedBlock as AnyDecodedBlock, type index$8_AnyLink as AnyLink, type index$8_AnyLinkFn as AnyLinkFn, index$8_AttachedRemotesImpl as AttachedRemotesImpl, type index$8_AttachedStores as AttachedStores, index$8_BaseActiveStore as BaseActiveStore, type index$8_BaseAttachedStores as BaseAttachedStores, index$8_BaseBlockstoreImpl as BaseBlockstoreImpl, type index$8_BaseStore as BaseStore, type index$8_BlockFetcher as BlockFetcher, type index$8_BlockstoreOpts as BlockstoreOpts, type index$8_BlockstoreParams as BlockstoreParams, type index$8_BlockstoreRuntime as BlockstoreRuntime, type index$8_BytesAndKeyWithIv as BytesAndKeyWithIv, type index$8_CIDActiveStore as CIDActiveStore, type index$8_CIDBlock as CIDBlock, index$8_Car2FPMsg as Car2FPMsg, index$8_CarActiveStore as CarActiveStore, type index$8_CarAttachedStores as CarAttachedStores, type index$8_CarCacheItem as CarCacheItem, type index$8_CarClockHead as CarClockHead, type index$8_CarClockLink as CarClockLink, type index$8_CarGroup as CarGroup, type index$8_CarHeader as CarHeader, index$8_CarLog as CarLog, type index$8_CarMakeable as CarMakeable, type index$8_CarStore as CarStore, index$8_CarTransactionImpl as CarTransactionImpl, type index$8_CarTransactionOpts as CarTransactionOpts, type index$8_CodecOpts as CodecOpts, type index$8_CommitOpts as CommitOpts, type index$8_CompactFetcher as CompactFetcher, type index$8_CompactFn as CompactFn, index$8_CompactionFetcher as CompactionFetcher, type index$8_Connection as Connection, type index$8_CryptoAction as CryptoAction, type index$8_DataAndMetaAndWalStore as DataAndMetaAndWalStore, type index$8_DataAndMetaStore as DataAndMetaStore, type index$8_DataSaveOpts as DataSaveOpts, type index$8_DbMeta as DbMeta, type index$8_DbMetaBinary as DbMetaBinary, type index$8_DbMetaEvent as DbMetaEvent, type index$8_DbMetaEventBlock as DbMetaEventBlock, index$8_DbMetaEventEqual as DbMetaEventEqual, index$8_DbMetaEventsEqual as DbMetaEventsEqual, type index$8_EncryptedBlock as EncryptedBlock, index$8_EncryptedBlockstore as EncryptedBlockstore, type index$8_FPEnvelope as FPEnvelope, type index$8_FPEnvelopeCar as FPEnvelopeCar, type index$8_FPEnvelopeFile as FPEnvelopeFile, type index$8_FPEnvelopeMeta as FPEnvelopeMeta, type index$8_FPEnvelopeType as FPEnvelopeType, index$8_FPEnvelopeTypes as FPEnvelopeTypes, type index$8_FPEnvelopeWAL as FPEnvelopeWAL, type index$8_FPWALCarsOps as FPWALCarsOps, index$8_File2FPMsg as File2FPMsg, index$8_FileActiveStore as FileActiveStore, type index$8_FileAttachedStores as FileAttachedStores, type index$8_FileStore as FileStore, type index$8_FroozenCarLog as FroozenCarLog, type index$8_Gateway as Gateway, type index$8_GatewayOpts as GatewayOpts, type index$8_GetResult as GetResult, index$8_InterceptorGateway as InterceptorGateway, type index$8_IvAndKeyAndBytes as IvAndKeyAndBytes, type index$8_IvKeyIdData as IvKeyIdData, type index$8_KeyMaterial as KeyMaterial, type index$8_KeyUpsertResult as KeyUpsertResult, type index$8_KeyWithFingerPrint as KeyWithFingerPrint, type index$8_KeysByFingerprint as KeysByFingerprint, type index$8_LoadHandler as LoadHandler, type index$8_Loadable as Loadable, index$8_Loader as Loader, type index$8_LocalActiveStore as LocalActiveStore, type index$8_LocalDataAndMetaAndWalStore as LocalDataAndMetaAndWalStore, index$8_MetaActiveStore as MetaActiveStore, type index$8_MetaAttachedStores as MetaAttachedStores, type index$8_MetaStore as MetaStore, index$8_PassThroughGateway as PassThroughGateway, type index$8_RefBlockstore as RefBlockstore, type index$8_RefLoadable as RefLoadable, type index$8_SerdeGateway as SerdeGateway, type index$8_SerdeGatewayBuildUrlOp as SerdeGatewayBuildUrlOp, type index$8_SerdeGatewayBuildUrlReturn as SerdeGatewayBuildUrlReturn, type index$8_SerdeGatewayCloseOp as SerdeGatewayCloseOp, type index$8_SerdeGatewayCloseReturn as SerdeGatewayCloseReturn, type index$8_SerdeGatewayCtx as SerdeGatewayCtx, type index$8_SerdeGatewayDeleteOp as SerdeGatewayDeleteOp, type index$8_SerdeGatewayDeleteReturn as SerdeGatewayDeleteReturn, type index$8_SerdeGatewayDestroyOp as SerdeGatewayDestroyOp, type index$8_SerdeGatewayDestroyReturn as SerdeGatewayDestroyReturn, type index$8_SerdeGatewayFactoryItem as SerdeGatewayFactoryItem, type index$8_SerdeGatewayGetOp as SerdeGatewayGetOp, type index$8_SerdeGatewayGetReturn as SerdeGatewayGetReturn, type index$8_SerdeGatewayInterceptor as SerdeGatewayInterceptor, type index$8_SerdeGatewayOpts as SerdeGatewayOpts, type index$8_SerdeGatewayPutOp as SerdeGatewayPutOp, type index$8_SerdeGatewayPutReturn as SerdeGatewayPutReturn, type index$8_SerdeGatewayReturn as SerdeGatewayReturn, type index$8_SerdeGatewayStartOp as SerdeGatewayStartOp, type index$8_SerdeGatewayStartReturn as SerdeGatewayStartReturn, type index$8_SerdeGatewaySubscribeOp as SerdeGatewaySubscribeOp, type index$8_SerdeGatewaySubscribeReturn as SerdeGatewaySubscribeReturn, type index$8_SerdeGetResult as SerdeGetResult, type index$8_SerdeOrGatewayFactoryItem as SerdeOrGatewayFactoryItem, type index$8_StoreEnDeFile as StoreEnDeFile, type index$8_StoreFactory as StoreFactory, type index$8_StoreFactoryItem as StoreFactoryItem, type index$8_StoreRuntime as StoreRuntime, type index$8_StoreRuntimeUrls as StoreRuntimeUrls, type index$8_StoreURIRuntime as StoreURIRuntime, type index$8_StoreURIs as StoreURIs, type index$8_StoreUrls as StoreUrls, type index$8_StoreUrlsOpts as StoreUrlsOpts, index$8_TaskManager as TaskManager, type index$8_TaskManagerParams as TaskManagerParams, type index$8_TransactionMeta as TransactionMeta, type index$8_TransactionWrapper as TransactionWrapper, index$8_URIInterceptor as URIInterceptor, type index$8_URIMapper as URIMapper, type index$8_UnsubscribeResult as UnsubscribeResult, type index$8_UrlAndInterceptor as UrlAndInterceptor, type index$8_VoidResult as VoidResult, index$8_WALActiveStore as WALActiveStore, type index$8_WALAttachedStores as WALAttachedStores, type index$8_WALState as WALState, type index$8_WALStore as WALStore, type index$8_WriteableDataAndMetaAndWalStore as WriteableDataAndMetaAndWalStore, type index$8_WriteableDataAndMetaStore as WriteableDataAndMetaStore, index$8_createAttachedStores as createAttachedStores, index$8_createDbMetaEvent as createDbMetaEvent, index$8_defaultGatewayFactoryItem as defaultGatewayFactoryItem, index$8_ensureStoreEnDeFile as ensureStoreEnDeFile, index$8_getDefaultURI as getDefaultURI, index$8_getGatewayFactoryItem as getGatewayFactoryItem, index$8_getInterceptableGateway as getInterceptableGateway, index$8_parseCarFile as parseCarFile, index$8_registerStoreProtocol as registerStoreProtocol, index$8_toCIDBlock as toCIDBlock, index$8_toStoreRuntime as toStoreRuntime };
+}
+
+interface WriteQueueParams {
+    readonly chunkSize: number;
+}
+declare function defaultWriteQueueOpts(opts?: Partial<WriteQueueParams>): WriteQueueParams;
+
+declare class IndexTree<K extends IndexKeyType, R extends DocFragment> {
+    cid?: AnyLink;
+    root?: ProllyNode<K, R>;
+}
+interface ProllyIndexRow<K extends IndexKeyType, T extends DocFragment> {
+    readonly id: string;
+    readonly key: IndexKey<K>;
+    readonly value: T;
+}
+interface ProllyNode<K extends IndexKeyType, T extends DocFragment> extends ProllyNode$1 {
+    getAllEntries(): PromiseLike<{
+        [x: string]: unknown;
+        result: ProllyIndexRow<K, T>[];
+    }>;
+    getMany<KI extends IndexKeyType>(removeIds: KI[]): Promise<{
+        result: IndexKey<K>[];
+    }>;
+    range(a: string, b: string): Promise<{
+        result: ProllyIndexRow<K, T>[];
+    }>;
+    get(key: string): Promise<{
+        result: ProllyIndexRow<K, T>[];
+    }>;
+    bulk(bulk: (IndexUpdate<K> | IndexUpdateString)[]): PromiseLike<{
+        readonly root?: ProllyNode<K, T>;
+        readonly blocks: Block$1[];
+    }>;
+    readonly address: Promise<Link>;
+    readonly distance: number;
+    compare: (a: unknown, b: unknown) => number;
+    readonly cache: unknown;
+    readonly block: Promise<Block$1>;
+}
+
+declare function index$7<K extends IndexKeyType = string, T extends DocTypes = NonNullable<unknown>, R extends DocFragment = T>(refDb: HasLogger & HasSuperThis & (HasCRDT | RefLedger), name: string, mapFn?: MapFn<T>, meta?: IdxMeta): Index<K, T, R>;
+declare class Index<K extends IndexKeyType, T extends DocTypes, R extends DocFragment = T> {
+    readonly blockstore: BaseBlockstore;
+    readonly crdt: CRDT;
+    readonly name: string;
+    mapFn?: MapFn<T>;
+    mapFnString: string;
+    byKey: IndexTree<K, R>;
+    byId: IndexTree<K, R>;
+    indexHead?: ClockHead;
+    includeDocsDefault: boolean;
+    initError?: Error;
+    ready(): Promise<void>;
+    readonly logger: Logger;
+    constructor(sthis: SuperThis, crdt: CRDT, name: string, mapFn?: MapFn<T>, meta?: IdxMeta);
+    applyMapFn(name: string, mapFn?: MapFn<T>, meta?: IdxMeta): void;
+    query(opts?: QueryOpts<K>): Promise<IndexRows<K, T, R>>;
+    _resetIndex(): void;
+    _hydrateIndex(): Promise<void>;
+    _updateIndex(): Promise<IndexTransactionMeta>;
+}
+
+type Falsy = false | null | undefined;
+type Unreg = () => void;
+declare function isFalsy(value: unknown): value is Falsy;
+declare const PARAM: {
+    SUFFIX: string;
+    URL_GEN: string;
+    STORE_KEY: string;
+    STORE: string;
+    KEY: string;
+    INDEX: string;
+    NAME: string;
+    VERSION: string;
+    RUNTIME: string;
+    FRAG_SIZE: string;
+    IV_VERIFY: string;
+    IV_HASH: string;
+    FRAG_FID: string;
+    FRAG_OFS: string;
+    FRAG_LEN: string;
+    FRAG_HEAD: string;
+    EXTRACTKEY: string;
+    SELF_REFLECT: string;
+    CAR_PARALLEL: string;
+    CAR_CACHE_SIZE: string;
+    CAR_COMPACT_CACHE_SIZE: string;
+    CAR_META_CACHE_SIZE: string;
+    GENESIS_CID: string;
+};
+type PARAMS = (typeof PARAM)[keyof typeof PARAM];
+declare function throwFalsy<T>(value: T | Falsy): T;
+declare function falsyToUndef<T>(value: T | Falsy): T | undefined;
+type StoreType = "car" | "file" | "wal" | "meta";
+interface FPStats {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+    uid: number | Falsy;
+    gid: number | Falsy;
+    size: number | Falsy;
+    atime: Date | Falsy;
+    mtime: Date | Falsy;
+    ctime: Date | Falsy;
+    birthtime: Date | Falsy;
+}
+interface SysFileSystem {
+    start(): Promise<SysFileSystem>;
+    mkdir(path: string, options?: {
+        recursive: boolean;
+    }): Promise<string | undefined>;
+    readdir(path: string): Promise<string[]>;
+    rm(path: string, options?: {
+        recursive: boolean;
+    }): Promise<void>;
+    copyFile(source: string, destination: string): Promise<void>;
+    readfile(path: string): Promise<Uint8Array>;
+    stat(path: string): Promise<FPStats>;
+    unlink(path: string): Promise<void>;
+    writefile(path: string, data: Uint8Array | string): Promise<void>;
+}
+interface PathOps {
+    join(...args: string[]): string;
+    dirname(path: string): string;
+    basename(path: string): string;
+}
+type ToUInt8 = Uint8Array | Result<Uint8Array>;
+type PromiseToUInt8 = ToUInt8 | Promise<Uint8Array> | Promise<Result<Uint8Array>>;
+interface TextEndeCoder {
+    encode(input: string): Uint8Array;
+    decode(input: ToUInt8): string;
+}
+interface SuperThisOpts {
+    readonly logger: Logger;
+    readonly pathOps: PathOps;
+    readonly crypto: CryptoRuntime;
+    readonly env: Partial<EnvFactoryOpts>;
+    readonly txt: TextEndeCoder;
+    readonly ctx: Record<string, unknown>;
+}
+interface SuperThis {
+    readonly logger: Logger;
+    readonly loggerCollector?: Logger;
+    readonly env: Env;
+    readonly pathOps: PathOps;
+    readonly ctx: Record<string, unknown>;
+    readonly txt: TextEndeCoder;
+    timeOrderedNextId(time?: number): {
+        str: string;
+        toString: () => string;
+    };
+    nextId(bytes?: number): {
+        str: string;
+        bin: Uint8Array;
+        toString: () => string;
+    };
+    start(): Promise<void>;
+    clone(override: Partial<SuperThisOpts>): SuperThis;
+}
+interface ConfigOpts extends Partial<SuperThisOpts> {
+    readonly public?: boolean;
+    readonly meta?: DbMeta;
+    readonly writeQueue?: Partial<WriteQueueParams>;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+    readonly autoCompact?: number;
+    readonly storeUrls?: StoreUrlsOpts;
+    readonly storeEnDe?: StoreEnDeFile;
+    readonly threshold?: number;
+    readonly keyBag?: Partial<KeyBagOpts>;
+}
+type ClockLink = EventLink<Operation>;
+type ClockHead = ClockLink[];
+type DocFragment = Uint8Array | string | number | boolean | null | AnyLink | DocFragment[] | object;
+type DocLiteral = string | number | boolean | Uint8Array | unknown;
+type DocObject = NonNullable<unknown>;
+type DocTypes = DocObject;
+type DocRecord<T extends DocObject> = T;
+type UnknownDoc = DocRecord<never>;
+type DocFiles = Record<string, DocFileMeta | File>;
+interface DocBase {
+    readonly _id: string;
+    readonly _files?: DocFiles;
+    readonly _publicFiles?: DocFiles;
+    readonly _deleted?: boolean;
+}
+type DocWithId<T extends DocTypes> = DocBase & T;
+type DocSet<T extends DocTypes> = Partial<DocBase> & T;
+interface DocFileMeta {
+    readonly type: string;
+    readonly size: number;
+    readonly cid: AnyLink;
+    readonly car?: AnyLink;
+    readonly lastModified?: number;
+    url?: string;
+    file?: () => Promise<File>;
+}
+interface DocUpdate<T extends DocTypes> {
+    readonly id: string;
+    readonly value?: DocSet<T>;
+    readonly del?: boolean;
+    readonly clock?: ClockLink;
+}
+interface DocValue<T extends DocTypes> {
+    readonly doc: DocWithId<T>;
+    readonly del: boolean;
+    readonly cid: AnyLink;
+}
+type KeyLiteral = string | number | boolean;
+type IndexKeyType = KeyLiteral | KeyLiteral[];
+type IndexKey<K extends IndexKeyType> = [K, string];
+interface IndexUpdate<K extends IndexKeyType> {
+    readonly key: IndexKey<K>;
+    readonly value?: DocFragment;
+    readonly del?: boolean;
+}
+interface IndexUpdateString {
+    readonly key: string;
+    readonly value?: DocFragment;
+    readonly del?: boolean;
+}
+interface IndexRow<K extends IndexKeyType, T extends DocObject, R extends DocFragment> {
+    readonly id: string;
+    readonly key: K;
+    readonly value: R;
+    readonly doc?: DocWithId<T>;
+}
+interface IndexRows<K extends IndexKeyType, T extends DocObject, R extends DocFragment = T> {
+    readonly rows: IndexRow<K, T, R>[];
+}
+interface CRDTMeta {
+    readonly head: ClockHead;
+}
+interface IndexTransactionMeta {
+    readonly indexes: Record<string, IdxMeta>;
+}
+interface FileTransactionMeta {
+    readonly files?: AnyLink[];
+}
+type MetaType = CRDTMeta | IndexTransactionMeta | FileTransactionMeta;
+interface IdxMeta {
+    readonly byId: AnyLink;
+    readonly byKey: AnyLink;
+    readonly map: string;
+    readonly name: string;
+    readonly head: ClockHead;
+}
+interface IdxMetaMap {
+    readonly indexes?: Map<string, IdxMeta>;
+}
+interface QueryOpts<K extends IndexKeyType> {
+    readonly descending?: boolean;
+    readonly limit?: number;
+    includeDocs?: boolean;
+    readonly range?: [IndexKeyType, IndexKeyType];
+    readonly key?: DocFragment;
+    readonly keys?: DocFragment[];
+    prefix?: IndexKeyType;
+}
+interface AllDocsQueryOpts extends QueryOpts<string> {
+    readonly key?: string;
+    readonly keys?: string[];
+    prefix?: string;
+}
+interface AllDocsResponse<T extends DocTypes> {
+    readonly rows: {
+        readonly key: string;
+        readonly value: DocWithId<T>;
+    }[];
+    readonly clock: ClockHead;
+    readonly name?: string;
+}
+type EmitFn = (k: IndexKeyType, v?: DocFragment) => void;
+type MapFn<T extends DocTypes> = (doc: DocWithId<T>, emit: EmitFn) => DocFragment | unknown;
+interface ChangesOptions {
+    readonly dirty?: boolean;
+    readonly limit?: number;
+}
+interface ChangesResponseRow<T extends DocTypes> {
+    readonly key: string;
+    readonly value: DocWithId<T>;
+    readonly clock?: ClockLink;
+}
+interface ChangesResponse<T extends DocTypes> {
+    readonly clock: ClockHead;
+    readonly rows: ChangesResponseRow<T>[];
+    readonly name?: string;
+}
+interface DocResponse {
+    readonly id: string;
+    readonly clock: ClockHead;
+    readonly name?: string;
+}
+interface BulkResponse {
+    readonly ids: string[];
+    readonly clock: ClockHead;
+    readonly name?: string;
+}
+type UpdateListenerFn<T extends DocTypes> = (docs: DocWithId<T>[]) => Promise<void> | void;
+type NoUpdateListenerFn = () => Promise<void> | void;
+type ListenerFn<T extends DocTypes> = UpdateListenerFn<T> | NoUpdateListenerFn;
+interface CRDTEntry {
+    readonly data: string;
+    readonly parents: string[];
+    readonly cid: string;
+}
+type VoidFn = () => void;
+type UnReg$1 = () => void;
+interface CRDTClock {
+    readonly head: ClockHead;
+    onTock(fn: VoidFn): UnReg$1;
+    onTick(fn: (updates: DocUpdate<DocTypes>[]) => void): UnReg$1;
+    applyHead(newHead: ClockHead, prevHead: ClockHead, updates?: DocUpdate<DocTypes>[]): Promise<void>;
+    onZoom(fn: VoidFn): UnReg$1;
+    close(): Promise<void>;
+    ready(): Promise<void>;
+}
+interface CarTransaction {
+    readonly parent: BaseBlockstore;
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block$1<T, C, A, V> | undefined>;
+    superGet(cid: AnyLink): Promise<AnyBlock | undefined>;
+    unshift(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): void;
+    putSync(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): void;
+    put(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): Promise<void>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+}
+interface BaseBlockstore {
+    readonly transactions: Set<CarTransaction>;
+    readonly sthis: SuperThis;
+    readonly loader: Loadable;
+    readonly ebOpts: BlockstoreRuntime;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    compact(): Promise<void>;
+    readonly logger: Logger;
+    get<T, C extends number, A extends number, V extends Version>(cid: AnyLink): Promise<Block$1<T, C, A, V> | undefined>;
+    put(cid: UnknownLink, bytes: Uint8Array<ArrayBufferLike>): Promise<void>;
+    transaction<M extends TransactionMeta>(fn: (t: CarTransaction) => Promise<M>, _opts?: CarTransactionOpts): Promise<TransactionWrapper<M>>;
+    openTransaction(opts: CarTransactionOpts): CarTransaction;
+    commitTransaction<M extends TransactionMeta>(t: CarTransaction, done: M, opts: CarTransactionOpts): Promise<TransactionWrapper<M>>;
+    entries(): AsyncIterableIterator<AnyBlock>;
+}
+interface CRDT extends ReadyCloseDestroy, HasLogger, HasSuperThis, HasCRDT {
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    readonly crdt: CRDT;
+    readonly clock: CRDTClock;
+    readonly blockstore: BaseBlockstore;
+    readonly indexBlockstore: BaseBlockstore;
+    readonly indexers: Map<string, Index<IndexKeyType, DocTypes>>;
+    bulk<T extends DocTypes>(updates: DocUpdate<T>[]): Promise<CRDTMeta>;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    allDocs<T extends DocTypes>(): Promise<{
+        result: DocUpdate<T>[];
+        head: ClockHead;
+    }>;
+    vis(): Promise<string>;
+    getBlock(cidString: string): Promise<Block$1>;
+    get(key: string): Promise<DocValue<DocTypes> | Falsy>;
+    changes<T extends DocTypes>(since?: ClockHead, opts?: ChangesOptions): Promise<{
+        result: DocUpdate<T>[];
+        head: ClockHead;
+    }>;
+    compact(): Promise<void>;
+}
+interface HasCRDT {
+    readonly crdt: CRDT;
+}
+interface RefLedger {
+    readonly ledger: Ledger;
+}
+interface HasLogger {
+    readonly logger: Logger;
+}
+interface HasSuperThis {
+    readonly sthis: SuperThis;
+}
+interface ReadyCloseDestroy {
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    ready(): Promise<void>;
+}
+interface CoerceURIandInterceptor {
+    readonly url: CoerceURI;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+}
+interface GatewayUrlsParam {
+    readonly car: CoerceURIandInterceptor;
+    readonly file: CoerceURIandInterceptor;
+    readonly meta: CoerceURIandInterceptor;
+    readonly wal?: CoerceURIandInterceptor;
+}
+interface GatewayUrls {
+    readonly car: UrlAndInterceptor;
+    readonly file: UrlAndInterceptor;
+    readonly meta: UrlAndInterceptor;
+    readonly wal?: UrlAndInterceptor;
+}
+interface Attachable {
+    readonly name: string;
+    prepare(): Promise<GatewayUrlsParam>;
+}
+declare class DataAndMetaAndWalAndBaseStore implements DataAndMetaAndWalStore {
+    readonly wal?: WALStore | undefined;
+    readonly file: FileStore;
+    readonly car: CarStore;
+    readonly meta: MetaStore;
+    readonly baseStores: BaseStore[];
+    constructor(dam: DataAndMetaAndWalStore);
+}
+interface Attached {
+    readonly gatewayUrls: GatewayUrls;
+    readonly stores: DataAndMetaAndWalAndBaseStore;
+    detach(): Promise<void>;
+    status(): "attached" | "loading" | "loaded" | "error" | "detached" | "syncing" | "idle";
+}
+interface Database extends ReadyCloseDestroy, HasLogger, HasSuperThis {
+    readonly ledger: Ledger;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    readonly id: string;
+    readonly name: string;
+    onClosed(fn: () => void): void;
+    attach(a: Attachable): Promise<Attached>;
+    get<T extends DocTypes>(id: string): Promise<DocWithId<T>>;
+    put<T extends DocTypes>(doc: DocSet<T>): Promise<DocResponse>;
+    bulk<T extends DocTypes>(docs: DocSet<T>[]): Promise<BulkResponse>;
+    del(id: string): Promise<DocResponse>;
+    remove(id: string): Promise<DocResponse>;
+    changes<T extends DocTypes>(since?: ClockHead, opts?: ChangesOptions): Promise<ChangesResponse<T>>;
+    allDocs<T extends DocTypes>(opts?: AllDocsQueryOpts): Promise<AllDocsResponse<T>>;
+    allDocuments<T extends DocTypes>(): Promise<{
+        rows: {
+            key: string;
+            value: DocWithId<T>;
+        }[];
+        clock: ClockHead;
+    }>;
+    subscribe<T extends DocTypes>(listener: ListenerFn<T>, updates?: boolean): () => void;
+    query<K extends IndexKeyType, T extends DocTypes, R extends DocFragment = T>(field: string | MapFn<T>, opts?: QueryOpts<K>): Promise<IndexRows<K, T, R>>;
+    compact(): Promise<void>;
+}
+interface WriteQueue<T extends DocUpdate<S>, S extends DocTypes = DocTypes> {
+    push(task: T): Promise<MetaType>;
+    bulk(tasks: T[]): Promise<MetaType>;
+    close(): Promise<void>;
+}
+interface LedgerOpts {
+    readonly name: string;
+    readonly meta?: DbMeta;
+    readonly gatewayInterceptor?: SerdeGatewayInterceptor;
+    readonly writeQueue: WriteQueueParams;
+    readonly storeUrls: StoreURIRuntime;
+    readonly storeEnDe: StoreEnDeFile;
+    readonly keyBag: KeyBagRuntime;
+}
+interface Ledger extends HasCRDT {
+    readonly opts: LedgerOpts;
+    readonly writeQueue: WriteQueue<DocUpdate<DocTypes>>;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    readonly id: string;
+    readonly name: string;
+    readonly context: Context;
+    onClosed(fn: () => void): () => void;
+    attach(a: Attachable): Promise<Attached>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    ready(): Promise<void>;
+    subscribe<T extends DocTypes>(listener: ListenerFn<T>, updates?: boolean): () => void;
+}
+
+declare function keyConfigOpts(sthis: SuperThis, name: string, opts?: ConfigOpts): string;
+declare function isLedger(db: unknown): db is Ledger;
+declare function LedgerFactory(name: string, opts?: ConfigOpts): Ledger;
+declare class LedgerShell implements Ledger {
+    readonly ref: LedgerImpl;
+    readonly writeQueue: WriteQueue<DocUpdate<DocTypes>>;
+    readonly name: string;
+    constructor(ref: LedgerImpl);
+    attach(a: Attachable): Promise<Attached>;
+    get opts(): LedgerOpts;
+    get context(): Context;
+    get id(): string;
+    get logger(): Logger;
+    get sthis(): SuperThis;
+    get crdt(): CRDT;
+    onClosed(fn: () => void): () => void;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    ready(): Promise<void>;
+    subscribe<T extends DocTypes>(listener: ListenerFn<T>, updates?: boolean): () => void;
+}
+declare class LedgerImpl implements Ledger {
+    readonly opts: LedgerOpts;
+    _listening: boolean;
+    readonly _listeners: Set<ListenerFn<{}>>;
+    readonly _noupdate_listeners: Set<ListenerFn<{}>>;
+    readonly crdt: CRDT;
+    readonly writeQueue: WriteQueue<DocUpdate<DocTypes>>;
+    readonly shells: Set<LedgerShell>;
+    readonly context: Context;
+    get name(): string;
+    addShell(shell: LedgerShell): void;
+    readonly _onClosedFns: Map<string, () => void>;
+    onClosed(fn: () => void): () => void;
+    close(): Promise<void>;
+    shellClose(db: LedgerShell): Promise<void>;
+    destroy(): Promise<void>;
+    readonly _ready: ResolveOnce<void>;
+    ready(): Promise<void>;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    readonly id: string;
+    constructor(sthis: SuperThis, opts: LedgerOpts);
+    attach(a: Attachable): Promise<Attached>;
+    subscribe<T extends DocTypes>(listener: ListenerFn<T>, updates?: boolean): () => void;
+    private _notify;
+    private _no_update_notify;
+}
+declare function toStoreURIRuntime(sthis: SuperThis, name: string, sopts?: StoreUrlsOpts): StoreURIRuntime;
+declare function fireproof(name: string, opts?: ConfigOpts): Database;
+
+declare function isDatabase(db: unknown): db is Database;
+declare class DatabaseImpl implements Database {
+    onClosed(fn: () => void): void;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    ready(): Promise<void>;
+    readonly ledger: Ledger;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    readonly id: string;
+    constructor(ledger: Ledger);
+    attach(a: Attachable): Promise<Attached>;
+    get name(): string;
+    get<T extends DocTypes>(id: string): Promise<DocWithId<T>>;
+    put<T extends DocTypes>(doc: DocSet<T>): Promise<DocResponse>;
+    bulk<T extends DocTypes>(docs: DocSet<T>[]): Promise<BulkResponse>;
+    del(id: string): Promise<DocResponse>;
+    remove(id: string): Promise<DocResponse>;
+    changes<T extends DocTypes>(since?: ClockHead, opts?: ChangesOptions): Promise<ChangesResponse<T>>;
+    allDocs<T extends DocTypes>(opts?: AllDocsQueryOpts): Promise<AllDocsResponse<T>>;
+    allDocuments<T extends DocTypes>(): Promise<{
+        rows: {
+            key: string;
+            value: DocWithId<T>;
+        }[];
+        clock: ClockHead;
+    }>;
+    subscribe<T extends DocTypes>(listener: ListenerFn<T>, updates?: boolean): () => void;
+    query<K extends IndexKeyType, T extends DocTypes, R extends DocFragment = T>(field: string | MapFn<T>, opts?: QueryOpts<K>): Promise<IndexRows<K, T, R>>;
+    compact(): Promise<void>;
+}
+
+declare class CRDTImpl implements CRDT {
+    readonly opts: LedgerOpts;
+    readonly blockstore: BaseBlockstore;
+    readonly indexBlockstore: BaseBlockstore;
+    readonly indexers: Map<string, Index<IndexKeyType, {}, {}>>;
+    readonly clock: CRDTClock;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    readonly crdt: CRDT;
+    constructor(sthis: SuperThis, opts: LedgerOpts);
+    bulk<T extends DocTypes>(updates: DocUpdate<T>[]): Promise<CRDTMeta>;
+    _bulk<T extends DocTypes>(updates: DocUpdate<T>[]): Promise<CRDTMeta>;
+    readonly onceReady: ResolveOnce<void>;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): Promise<void>;
+    allDocs<T extends DocTypes>(): Promise<{
+        result: DocUpdate<T>[];
+        head: ClockHead;
+    }>;
+    vis(): Promise<string>;
+    getBlock(cidString: string): Promise<Block$1>;
+    get(key: string): Promise<DocValue<DocTypes> | Falsy>;
+    changes<T extends DocTypes>(since?: ClockHead, opts?: ChangesOptions): Promise<{
+        result: DocUpdate<T>[];
+        head: ClockHead;
+    }>;
+    compact(): Promise<void>;
+}
+
+declare function getPath(url: URI, sthis: SuperThis): string;
+declare function getFileName(url: URI, sthis: SuperThis): string;
+
+declare function encodeFile(blob: Blob): Promise<{
+    cid: AnyLink;
+    blocks: AnyBlock[];
+}>;
+interface BlockGetter {
+    get(cid: AnyLink): Promise<Uint8Array>;
+}
+declare function decodeFile(blocks: unknown, cid: AnyLink, meta: DocFileMeta): Promise<Result<File>>;
+
+type files_BlockGetter = BlockGetter;
+declare const files_decodeFile: typeof decodeFile;
+declare const files_encodeFile: typeof encodeFile;
+declare namespace files {
+  export { type files_BlockGetter as BlockGetter, files_decodeFile as decodeFile, files_encodeFile as encodeFile };
+}
+
+declare class BlockIvKeyIdCodec implements AsyncBlockCodec<24, Uint8Array, IvKeyIdData> {
+    readonly code = 24;
+    readonly name = "Fireproof@encrypted-block:aes-gcm";
+    readonly ko: CryptoAction;
+    readonly iv?: Uint8Array;
+    readonly opts: Partial<CodecOpts>;
+    constructor(ko: CryptoAction, iv?: Uint8Array, opts?: CodecOpts);
+    valueToHashBytes(value: IvKeyIdData): Promise<ByteView<unknown>>;
+    bytesToHash(data: Uint8Array): Promise<ByteView<unknown>>;
+    encode(data: Uint8Array): Promise<Uint8Array>;
+    decode(abytes: Uint8Array | ArrayBuffer): Promise<IvKeyIdData>;
+}
+declare function keyedCryptoFactory(url: URI, kb: KeyBag, sthis: SuperThis): Promise<CryptoAction>;
+
+type keyedCrypto_BlockIvKeyIdCodec = BlockIvKeyIdCodec;
+declare const keyedCrypto_BlockIvKeyIdCodec: typeof BlockIvKeyIdCodec;
+declare const keyedCrypto_keyedCryptoFactory: typeof keyedCryptoFactory;
+declare namespace keyedCrypto {
+  export { keyedCrypto_BlockIvKeyIdCodec as BlockIvKeyIdCodec, keyedCrypto_keyedCryptoFactory as keyedCryptoFactory };
+}
+
+declare const Block: typeof Block$2;
+interface DecodeInput<T, Code extends number, Alg extends number> {
+    readonly bytes: ByteView<unknown>;
+    readonly codec: BlockDecoder<Code, T>;
+    readonly hasher: MultihashHasher<Alg>;
+}
+interface AsyncDecodeInput<T, Code extends number, Alg extends number> {
+    readonly bytes: ByteView<unknown>;
+    readonly codec: AsyncBlockDecoder<Code, T>;
+    readonly hasher: MultihashHasher<Alg>;
+}
+declare function decode<T, Code extends number, Alg extends number>({ bytes, codec, hasher, }: AsyncDecodeInput<T, Code, Alg> | DecodeInput<T, Code, Alg>): Promise<BlockView<T, Code, Alg>>;
+interface EncodeInput<T, Code extends number, Alg extends number> {
+    readonly value: T;
+    readonly codec: BlockEncoder<Code, T>;
+    readonly hasher: MultihashHasher<Alg>;
+}
+interface AsyncEncodeInput<T, Code extends number, Alg extends number> {
+    readonly value: T;
+    readonly codec: AsyncBlockEncoder<Code, T>;
+    readonly hasher: MultihashHasher<Alg>;
+}
+declare function encode<T, Code extends number, Alg extends number>({ value, codec, hasher, }: AsyncEncodeInput<T, Code, Alg> | EncodeInput<T, Code, Alg>): Promise<BlockView<T, Code, Alg>>;
+interface CreateInput<T, Code extends number, Alg extends number, V extends Version> {
+    bytes: ByteView<T>;
+    cid: Link<T, Code, Alg, V>;
+    hasher: MultihashHasher<Alg>;
+    codec: BlockDecoder<Code, T>;
+}
+declare function create<T, Code extends number, Alg extends number, V extends Version>({ bytes, cid, hasher, codec, }: CreateInput<T, Code, Alg, V>): Promise<BlockView<T, Code, Alg, V>>;
+type CreateUnsafeInput<T, Code extends number, Alg extends number, V extends Version> = {
+    cid: Link<T, Code, Alg, V>;
+    value: T;
+    codec?: BlockDecoder<Code, T>;
+    bytes: ByteView<T>;
+} | {
+    cid: Link<T, Code, Alg, V>;
+    value?: undefined;
+    codec: BlockDecoder<Code, T>;
+    bytes: ByteView<T>;
+};
+declare function createUnsafe<T, Code extends number, Alg extends number, V extends Version>({ bytes, cid, value: maybeValue, codec, }: CreateUnsafeInput<T, Code, Alg, V>): Promise<BlockView<T, Code, Alg, V>>;
+
+type block_AsyncDecodeInput<T, Code extends number, Alg extends number> = AsyncDecodeInput<T, Code, Alg>;
+type block_AsyncEncodeInput<T, Code extends number, Alg extends number> = AsyncEncodeInput<T, Code, Alg>;
+declare const block_Block: typeof Block;
+type block_DecodeInput<T, Code extends number, Alg extends number> = DecodeInput<T, Code, Alg>;
+type block_EncodeInput<T, Code extends number, Alg extends number> = EncodeInput<T, Code, Alg>;
+declare const block_create: typeof create;
+declare const block_createUnsafe: typeof createUnsafe;
+declare const block_decode: typeof decode;
+declare const block_encode: typeof encode;
+declare namespace block {
+  export { type block_AsyncDecodeInput as AsyncDecodeInput, type block_AsyncEncodeInput as AsyncEncodeInput, block_Block as Block, type block_DecodeInput as DecodeInput, type block_EncodeInput as EncodeInput, block_create as create, block_createUnsafe as createUnsafe, block_decode as decode, block_encode as encode };
+}
+
+declare const index$6_block: typeof block;
+declare namespace index$6 {
+  export { index$6_block as block, codecInterface as codec };
+}
+
+interface ReqGetData extends ReqSignedUrl {
+    readonly type: "reqGetData";
+}
+declare function buildReqGetData(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqGetData;
+declare function MsgIsReqGetData(msg: MsgBase): msg is ReqGetData;
+interface ResGetData extends ResSignedUrl {
+    readonly type: "resGetData";
+}
+declare function MsgIsResGetData(msg: MsgBase): msg is ResGetData;
+interface CalculatePreSignedUrl {
+    calculatePreSignedUrl(ctx: MsgTypesCtx, p: PreSignedMsg): Promise<Result<URI>>;
+}
+declare function buildResGetData(msgCtx: MsgTypesCtx, req: MsgWithConnAuth<ReqGetData>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResGetData>>;
+interface ReqPutData extends ReqSignedUrl {
+    readonly type: "reqPutData";
+}
+declare function MsgIsReqPutData(msg: MsgBase): msg is ReqPutData;
+declare function buildReqPutData(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqPutData;
+interface ResPutData extends ResSignedUrl {
+    readonly type: "resPutData";
+}
+declare function MsgIsResPutData(msg: MsgBase): msg is ResPutData;
+declare function buildResPutData(msgCtx: MsgTypesCtx, req: MsgWithConnAuth<ReqPutData>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResPutData>>;
+interface ReqDelData extends ReqSignedUrl {
+    readonly type: "reqDelData";
+}
+declare function MsgIsReqDelData(msg: MsgBase): msg is ReqDelData;
+declare function buildReqDelData(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqDelData;
+interface ResDelData extends ResSignedUrl {
+    readonly type: "resDelData";
+}
+declare function MsgIsResDelData(msg: MsgBase): msg is ResDelData;
+declare function buildResDelData(msgCtx: MsgTypesCtx, req: MsgWithConnAuth<ReqDelData>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResDelData>>;
+
+declare const VERSION = "FP-MSG-1.0";
+interface BaseTokenParam {
+    readonly alg: string;
+    readonly issuer: string;
+    readonly audience: string;
+    readonly validFor: number;
+}
+interface FPCloudClaim extends JWTPayload {
+    readonly userId: string;
+    readonly tenants: {
+        readonly id: string;
+        readonly role: string;
+    }[];
+    readonly ledgers: {
+        readonly id: string;
+        readonly role: string;
+        readonly right: string;
+    }[];
+}
+type TokenForParam = FPCloudClaim & Partial<BaseTokenParam>;
+type MsgWithError<T extends MsgBase> = T | ErrorMsg;
+interface PreSignedMsg extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly methodParams: MethodSignedUrlParam;
+    readonly params: SignedUrlParam;
+}
+interface RequestOpts {
+    readonly waitFor: (msg: MsgBase) => boolean;
+    readonly pollInterval?: number;
+    readonly timeout?: number;
+}
+interface EnDeCoder {
+    encode<T>(node: T): Uint8Array;
+    decode<T>(data: Uint8Array): T;
+}
+interface WaitForTid {
+    readonly tid: string;
+    readonly future: Future<MsgBase>;
+    readonly timeout?: number;
+    readonly waitFor: (msg: MsgBase) => boolean;
+}
+interface NextId {
+    readonly nextId: SuperThis$1["nextId"];
+}
+interface AuthType {
+    readonly type: "ucan" | "error" | "fp-cloud-jwk" | "fp-cloud";
+}
+declare function isAuthTypeFPCloudJWK(a: AuthType): a is FPJWKCloudAuthType;
+declare function isAuthTypeFPCloud(a: AuthType): a is FPCloudAuthType;
+interface UCanAuth extends AuthType {
+    readonly type: "ucan";
+    readonly params: {
+        readonly tbd: string;
+    };
+}
+interface FPJWKCloudAuthType extends AuthType {
+    readonly type: "fp-cloud-jwk";
+    readonly params: {
+        readonly jwk: string;
+    };
+}
+interface FPCloudAuthType extends AuthType {
+    readonly type: "fp-cloud";
+    readonly params: {
+        readonly claim: TokenForParam;
+        readonly jwk: string;
+    };
+}
+type AuthFactory = (tp?: Partial<TokenForParam>) => Promise<Result<AuthType>>;
+interface TenantLedger {
+    readonly tenant: string;
+    readonly ledger: string;
+}
+declare function keyTenantLedger(t: TenantLedger): string;
+interface QSId {
+    readonly reqId: string;
+    readonly resId: string;
+}
+declare function qsidEqual(a: QSId, b: QSId): boolean;
+declare function qsidKey(qsid: QSId): string;
+interface MsgBase {
+    readonly tid: string;
+    readonly type: string;
+    readonly version: string;
+    readonly auth: AuthType;
+}
+declare function MsgIsTid(msg: MsgBase, tid: string): boolean;
+type MsgWithConn<T extends MsgBase = MsgBase> = T & {
+    readonly conn: QSId;
+};
+type MsgWithConnAuth<T extends MsgBase = MsgBase> = MsgWithConn<T> & {
+    readonly auth: AuthType;
+};
+type MsgWithTenantLedger<T extends MsgWithConnAuth> = T & {
+    readonly tenant: TenantLedger;
+};
+interface ErrorMsg extends MsgBase {
+    readonly type: "error";
+    readonly src: unknown;
+    readonly message: string;
+    readonly body?: string;
+    readonly stack?: string[];
+}
+declare function MsgIsError(rq: MsgBase): rq is ErrorMsg;
+declare function MsgIsQSError(rq: ReqRes<MsgBase, MsgBase>): rq is ReqRes<ErrorMsg, ErrorMsg>;
+type HttpMethods = "GET" | "PUT" | "DELETE";
+type FPStoreTypes = "meta" | "car" | "wal" | "file";
+declare function coerceFPStoreTypes(s?: string): FPStoreTypes;
+type ProtocolCapabilities = "reqRes" | "stream";
+declare function isProtocolCapabilities(s: string): s is ProtocolCapabilities;
+interface Gestalt {
+    readonly storeTypes: FPStoreTypes[];
+    readonly id: string;
+    readonly protocolCapabilities: ProtocolCapabilities[];
+    readonly httpEndpoints: string[];
+    readonly wsEndpoints: string[];
+    readonly encodings: ("JSON" | "CBOR")[];
+    readonly auth: AuthType[];
+    readonly requiresAuth: boolean;
+    readonly data?: {
+        readonly inband: boolean;
+        readonly outband: boolean;
+    };
+    readonly meta?: {
+        readonly inband: true;
+        readonly outband: boolean;
+    };
+    readonly wal?: {
+        readonly inband: boolean;
+        readonly outband: boolean;
+    };
+    readonly reqTypes: string[];
+    readonly resTypes: string[];
+    readonly eventTypes: string[];
+}
+interface MsgerParams {
+    readonly mime: string;
+    readonly auth?: AuthType;
+    readonly hasPersistent?: boolean;
+    readonly protocolCapabilities?: ProtocolCapabilities[];
+    readonly timeout: number;
+}
+type GestaltParam = Partial<Gestalt> & {
+    readonly id: string;
+};
+declare function defaultGestalt(msgP: MsgerParams, gestalt: GestaltParam): Gestalt;
+interface ReqChat extends MsgWithConn {
+    readonly type: "reqChat";
+    readonly message: string;
+    readonly targets: QSId[];
+}
+interface ResChat extends MsgWithConn {
+    readonly type: "resChat";
+    readonly message: string;
+    readonly targets: QSId[];
+}
+declare function buildReqChat(sthis: NextId, auth: AuthType, conn: QSId, message: string, targets?: QSId[]): ReqChat;
+declare function buildResChat(req: ReqChat, conn?: QSId, message?: string, targets?: QSId[], auth?: AuthType): ResChat;
+declare function MsgIsReqChat(msg: MsgBase): msg is ReqChat;
+declare function MsgIsResChat(msg: MsgBase): msg is ResChat;
+interface ReqGestalt extends MsgBase {
+    readonly type: "reqGestalt";
+    readonly gestalt: Gestalt;
+    readonly publish?: boolean;
+}
+declare function MsgIsReqGestalt(msg: MsgBase): msg is ReqGestalt;
+declare function buildReqGestalt(sthis: NextId, auth: AuthType, gestalt: Gestalt, publish?: boolean): ReqGestalt;
+interface ConnInfo {
+    readonly connIds: string[];
+}
+interface ResGestalt extends MsgBase {
+    readonly type: "resGestalt";
+    readonly gestalt: Gestalt;
+}
+declare function buildResGestalt(req: ReqGestalt, gestalt: Gestalt, auth: AuthType): ResGestalt | ErrorMsg;
+declare function MsgIsResGestalt(msg: MsgBase): msg is ResGestalt;
+interface ReqOpenConnection {
+    readonly reqId?: string;
+    readonly resId?: string;
+}
+interface ReqOpenConn {
+    readonly reqId: string;
+    readonly resId?: string;
+}
+interface ReqOpen extends MsgBase {
+    readonly type: "reqOpen";
+    readonly conn: ReqOpenConn;
+}
+declare function buildReqOpen(sthis: NextId, auth: AuthType, conn: ReqOpenConnection): ReqOpen;
+declare function MsgIsReqOpen(imsg: MsgBase): imsg is MsgWithConn<ReqOpen>;
+interface ResOpen extends MsgBase {
+    readonly type: "resOpen";
+    readonly conn: QSId;
+}
+declare function MsgIsWithConn<T extends MsgBase>(msg: T): msg is MsgWithConn<T>;
+declare function MsgIsWithConnAuth<T extends MsgBase>(msg: T): msg is MsgWithConnAuth<T>;
+declare function MsgIsConnected<T extends MsgBase>(msg: T, qsid: QSId): msg is MsgWithConn<T>;
+declare function buildResOpen(sthis: NextId, req: ReqOpen, resStreamId?: string): ResOpen;
+declare function MsgIsResOpen(msg: MsgBase): msg is ResOpen;
+interface ReqClose extends MsgWithConn {
+    readonly type: "reqClose";
+}
+declare function MsgIsReqClose(msg: MsgBase): msg is ReqClose;
+interface ResClose extends MsgWithConn {
+    readonly type: "resClose";
+}
+declare function MsgIsResClose(msg: MsgBase): msg is ResClose;
+declare function buildResClose(req: ReqClose, conn: QSId): ResClose;
+declare function buildReqClose(sthis: NextId, auth: AuthType, conn: QSId): ReqClose;
+interface SignedUrlParam {
+    readonly path?: string;
+    readonly key: string;
+    readonly expires?: number;
+    readonly index?: string;
+}
+interface MethodSignedUrlParam {
+    readonly method: HttpMethods;
+    readonly store: FPStoreTypes;
+}
+interface ReqSignedUrlParam {
+    readonly auth: AuthType;
+    readonly methodParam: MethodSignedUrlParam;
+    readonly params: SignedUrlParam;
+}
+interface UpdateReqRes<Q extends MsgBase, S extends MsgBase> {
+    req: Q;
+    res: S;
+}
+type ReqRes<Q extends MsgBase, S extends MsgBase> = Readonly<UpdateReqRes<Q, S>>;
+declare function buildErrorMsg(msgCtx: {
+    readonly logger: Logger;
+    readonly sthis: SuperThis$1;
+}, base: Partial<MsgBase & {
+    ref?: unknown;
+}>, error: Error, body?: string, stack?: string[]): ErrorMsg;
+declare function MsgIsTenantLedger<T extends MsgBase>(msg: T): msg is MsgWithTenantLedger<MsgWithConnAuth<T>>;
+interface ReqSignedUrl extends ReqSignedUrlWithoutMethodParams {
+    readonly methodParams: MethodSignedUrlParam;
+}
+interface ReqSignedUrlWithoutMethodParams extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly params: SignedUrlParam;
+}
+interface GwCtx {
+    readonly tid?: string;
+    readonly conn: QSId;
+    readonly tenant: TenantLedger;
+}
+interface GwCtxConn {
+    readonly tid?: string;
+    readonly conn: QSId;
+    readonly tenant: TenantLedger;
+}
+declare function buildReqSignedUrl<T extends ReqSignedUrl>(sthis: NextId, type: string, rparam: ReqSignedUrlParam, gwCtx: GwCtx): T;
+interface ResSignedUrl extends MsgWithTenantLedger<MsgWithConn> {
+    readonly methodParams: MethodSignedUrlParam;
+    readonly params: SignedUrlParam;
+    readonly signedUrl: string;
+}
+interface ResOptionalSignedUrl extends MsgWithTenantLedger<MsgWithConn> {
+    readonly params: SignedUrlParam;
+    readonly methodParams: MethodSignedUrlParam;
+    readonly signedUrl?: string;
+}
+interface MsgTypesCtx {
+    readonly sthis: SuperThis$1;
+    readonly logger: Logger;
+}
+interface MsgTypesCtxSync {
+    readonly sthis: SuperThis$1;
+    readonly logger: Logger;
+    readonly auth: AuthType;
+}
+declare function resAuth(msg: MsgBase): Promise<AuthType>;
+declare function buildRes<Q extends MsgWithTenantLedger<MsgWithConn<ReqSignedUrlWithoutMethodParams>>, S extends ResSignedUrl>(methodParams: MethodSignedUrlParam, type: string, msgCtx: MsgTypesCtx, req: Q, ctx: CalculatePreSignedUrl): Promise<MsgWithError<S>>;
+
+declare const envKeyDefaults: {
+    SECRET: string;
+    PUBLIC: string;
+};
+interface SessionTokenServiceParam extends Partial<BaseTokenParam> {
+    readonly token: string;
+}
+interface SessionTokenServiceFromEnvParam extends Partial<BaseTokenParam> {
+    readonly privateEnvKey?: string;
+    readonly publicEnvKey?: string;
+}
+declare function jwk2env(jwk: CryptoKey, sthis?: SuperThis): Promise<string>;
+declare function env2jwk(env: string, alg: string, sthis?: SuperThis): Promise<CryptoKey>;
+interface KeysResult {
+    readonly material: CryptoKeyPair;
+    readonly strings: {
+        readonly publicKey: string;
+        readonly privateKey: string;
+    };
+}
+declare class SessionTokenService {
+    #private;
+    static generateKeyPair(alg?: string, options?: GenerateKeyPairOptions, generateKeyPairFN?: (alg: string, options: GenerateKeyPairOptions) => Promise<jose.GenerateKeyPairResult>): Promise<KeysResult>;
+    static createFromEnv(sthis: SuperThis, sp?: SessionTokenServiceFromEnvParam): Promise<SessionTokenService>;
+    static create(stsparam: SessionTokenServiceParam, sthis?: SuperThis): Promise<SessionTokenService>;
+    private constructor();
+    get validFor(): number;
+    get alg(): string;
+    get isssuer(): string;
+    get audience(): string;
+    validate(token: string): Promise<Result<JWTVerifyResult<FPCloudClaim>>>;
+    tokenFor(p: TokenForParam): Promise<string>;
+}
+
+type index$5_KeysResult = KeysResult;
+type index$5_SessionTokenService = SessionTokenService;
+declare const index$5_SessionTokenService: typeof SessionTokenService;
+declare const index$5_env2jwk: typeof env2jwk;
+declare const index$5_envKeyDefaults: typeof envKeyDefaults;
+declare const index$5_jwk2env: typeof jwk2env;
+declare namespace index$5 {
+  export { type index$5_KeysResult as KeysResult, index$5_SessionTokenService as SessionTokenService, index$5_env2jwk as env2jwk, index$5_envKeyDefaults as envKeyDefaults, index$5_jwk2env as jwk2env };
+}
+
+interface KeyBagCtx {
+    readonly dirName: string;
+    readonly sysFS: SysFileSystem;
+    readonly fName: string;
+}
+declare class KeyBagProviderFile implements KeyBagProvider {
+    _prepare(id: string): Promise<KeyBagCtx>;
+    private readonly url;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    constructor(url: URI, sthis: SuperThis);
+    get(id: string): Promise<V1StorageKeyItem | KeysItem | undefined>;
+    set(item: KeysItem): Promise<void>;
+}
+
+declare function sysFileSystemFactory(uri: URI): Promise<SysFileSystem>;
+
+type index$4_KeyBagProviderFile = KeyBagProviderFile;
+declare const index$4_KeyBagProviderFile: typeof KeyBagProviderFile;
+declare const index$4_sysFileSystemFactory: typeof sysFileSystemFactory;
+declare namespace index$4 {
+  export { index$4_KeyBagProviderFile as KeyBagProviderFile, index$4_sysFileSystemFactory as sysFileSystemFactory };
+}
+
+declare class MemoryGateway implements Gateway {
+    readonly memorys: Map<string, Uint8Array>;
+    readonly sthis: SuperThis;
+    constructor(sthis: SuperThis, memorys: Map<string, Uint8Array>);
+    buildUrl(baseUrl: URI, key: string): Promise<Result<URI>>;
+    start(baseUrl: URI): Promise<Result<URI>>;
+    close(baseUrl: URI): Promise<VoidResult>;
+    destroy(baseUrl: URI): Promise<VoidResult>;
+    put(url: URI, bytes: Uint8Array): Promise<VoidResult>;
+    get(url: URI): Promise<GetResult>;
+    delete(url: URI): Promise<VoidResult>;
+    getPlain(url: URI, key: string): Promise<Result<Uint8Array>>;
+}
+
+type gateway$1_MemoryGateway = MemoryGateway;
+declare const gateway$1_MemoryGateway: typeof MemoryGateway;
+declare namespace gateway$1 {
+  export { gateway$1_MemoryGateway as MemoryGateway };
+}
+
+declare function selectRandom<T>(arr: T[]): T;
+declare function timeout<T>(ms: number, promise: Promise<T>): Promise<T>;
+type OnMsgFn<T extends MsgBase = MsgBase> = (msg: MsgWithError<T>) => void;
+type UnReg = () => void;
+interface ExchangedGestalt {
+    readonly my: Gestalt;
+    readonly remote: Gestalt;
+}
+type OnErrorFn = (msg: Partial<MsgBase>, err: Error) => Partial<MsgBase>;
+interface ActiveStream<S extends MsgBase, Q extends MsgBase> {
+    readonly id: string;
+    readonly bind: {
+        readonly msg: Q;
+        readonly opts: RequestOpts;
+    };
+    timeout?: unknown;
+    controller?: ReadableStreamDefaultController<MsgWithError<S>>;
+}
+interface MsgRawConnection<T extends MsgBase = MsgBase> {
+    readonly sthis: SuperThis;
+    readonly exchangedGestalt: ExchangedGestalt;
+    readonly activeBinds: Map<string, ActiveStream<T, MsgBase>>;
+    bind<S extends T, Q extends T>(req: Q, opts: RequestOpts): ReadableStream<MsgWithError<S>>;
+    request<S extends T, Q extends T>(req: Q, opts: RequestOpts): Promise<MsgWithError<S>>;
+    send<S extends T, Q extends T>(msg: Q): Promise<MsgWithError<S>>;
+    start(): Promise<Result<void>>;
+    close(o: T): Promise<Result<void>>;
+    onMsg(msg: OnMsgFn<T>): UnReg;
+}
+declare function jsonEnDe(sthis: SuperThis): EnDeCoder;
+type MsgerParamsWithEnDe = MsgerParams & {
+    readonly ende: EnDeCoder;
+};
+declare function defaultMsgParams(sthis: SuperThis, igs: Partial<MsgerParamsWithEnDe>): MsgerParamsWithEnDe;
+interface OpenParams {
+    readonly timeout: number;
+}
+declare function applyStart(prC: Promise<Result<MsgRawConnection>>): Promise<Result<MsgRawConnection>>;
+declare function authTypeFromUri(logger: Logger, curi: CoerceURI): Promise<Result<FPJWKCloudAuthType>>;
+declare class MsgConnected {
+    static connect(auth: AuthType, mrc: Result<MsgRawConnection> | MsgRawConnection, conn?: Partial<QSId>): Promise<Result<MsgConnected>>;
+    readonly sthis: SuperThis;
+    readonly conn: QSId;
+    readonly raw: MsgRawConnection;
+    readonly exchangedGestalt: ExchangedGestalt;
+    readonly activeBinds: Map<string, ActiveStream<MsgWithConnAuth, MsgBase>>;
+    readonly id: string;
+    private constructor();
+    attachAuth(auth: AuthFactory): MsgConnectedAuth;
+}
+declare class MsgConnectedAuth implements MsgRawConnection<MsgWithConnAuth> {
+    readonly sthis: SuperThis;
+    readonly conn: QSId;
+    readonly raw: MsgRawConnection;
+    readonly exchangedGestalt: ExchangedGestalt;
+    readonly activeBinds: Map<string, ActiveStream<MsgWithConnAuth, MsgBase>>;
+    readonly id: string;
+    readonly authFactory: AuthFactory;
+    constructor(conn: MsgConnected, authFactory: AuthFactory);
+    bind<S extends MsgWithConnAuth, Q extends MsgWithConnAuth>(req: Q, opts: RequestOpts): ReadableStream<MsgWithError<S>>;
+    authType(): Promise<Result<AuthType>>;
+    msgConnAuth(): Promise<Result<MsgWithConnAuth>>;
+    request<S extends MsgWithConnAuth, Q extends MsgWithConnAuth>(req: Q, opts: RequestOpts): Promise<MsgWithError<S>>;
+    send<S extends MsgWithConnAuth, Q extends MsgWithConnAuth>(msg: Q): Promise<MsgWithError<S>>;
+    start(): Promise<Result<void>>;
+    close(t: MsgWithConnAuth): Promise<Result<void>>;
+    onMsg(msgFn: OnMsgFn<MsgWithConnAuth>): UnReg;
+}
+declare class Msger {
+    static openHttp(sthis: SuperThis, urls: URI[], msgP: MsgerParamsWithEnDe, exGestalt: ExchangedGestalt): Promise<Result<MsgRawConnection>>;
+    static openWS(sthis: SuperThis, url: URI, msgP: MsgerParamsWithEnDe, exGestalt: ExchangedGestalt): Promise<Result<MsgRawConnection>>;
+    static open(sthis: SuperThis, auth: AuthType, curl: CoerceURI, imsgP?: Partial<MsgerParamsWithEnDe>): Promise<Result<MsgRawConnection>>;
+    static connect(sthis: SuperThis, auth: AuthType, curl: CoerceURI, imsgP?: Partial<MsgerParamsWithEnDe>, conn?: Partial<QSId>): Promise<Result<MsgConnected>>;
+    private constructor();
+}
+
+type ConnectedSerdeGatewayCtx = SerdeGatewayCtx & {
+    conn: AuthedConnection;
+};
+interface StoreTypeGateway {
+    get: <S>(ctx: ConnectedSerdeGatewayCtx, url: URI) => Promise<SerdeGetResult<S>>;
+    put: <T>(ctx: ConnectedSerdeGatewayCtx, url: URI, body: FPEnvelope<T>) => Promise<VoidResult>;
+    delete: (ctx: ConnectedSerdeGatewayCtx, url: URI) => Promise<VoidResult>;
+}
+interface ConnectionItem {
+    readonly uri: URI;
+    readonly matchRes: MatchResult;
+    readonly connection: ResolveOnce<Result<MsgConnected>>;
+    readonly trackPuts: Set<string>;
+}
+interface AuthedConnection {
+    readonly conn: Result<MsgConnectedAuth>;
+    readonly citem: ConnectionItem;
+}
+declare class FireproofCloudGateway implements SerdeGateway {
+    #private;
+    readonly logger: Logger;
+    readonly sthis: SuperThis;
+    constructor(sthis: SuperThis);
+    buildUrl(ctx: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<URI>>;
+    start(ctx: SerdeGatewayCtx, uri: URI): Promise<Result<URI>>;
+    get<S>(ctx: SerdeGatewayCtx, uri: URI): Promise<SerdeGetResult<S>>;
+    put<T>(ctx: SerdeGatewayCtx, uri: URI, body: FPEnvelope<T>): Promise<VoidResult>;
+    delete(ctx: SerdeGatewayCtx, uri: URI): Promise<VoidResult>;
+    close(ctx: SerdeGatewayCtx, uri: URI): Promise<VoidResult>;
+    getCloudConnection(uri: URI): Promise<Result<MsgConnectedAuth>>;
+    getCloudConnectionItem(uri: URI): Promise<AuthedConnection>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<UnsubscribeResult>;
+    destroy(ctx: SerdeGatewayCtx, uri: URI): Promise<VoidResult>;
+    getPlain(): Promise<Result<Uint8Array>>;
+}
+declare function registerFireproofCloudStoreProtocol(protocol?: string): () => void;
+declare function toCloud(url: CoerceURI): Attachable;
+
+type gateway_FireproofCloudGateway = FireproofCloudGateway;
+declare const gateway_FireproofCloudGateway: typeof FireproofCloudGateway;
+type gateway_StoreTypeGateway = StoreTypeGateway;
+declare const gateway_registerFireproofCloudStoreProtocol: typeof registerFireproofCloudStoreProtocol;
+declare const gateway_toCloud: typeof toCloud;
+declare namespace gateway {
+  export { gateway_FireproofCloudGateway as FireproofCloudGateway, type gateway_StoreTypeGateway as StoreTypeGateway, gateway_registerFireproofCloudStoreProtocol as registerFireproofCloudStoreProtocol, gateway_toCloud as toCloud };
+}
+
+declare class DefSerdeGateway implements SerdeGateway {
+    readonly gw: Gateway;
+    constructor(gw: Gateway);
+    start({ loader: { sthis } }: SerdeGatewayCtx, baseURL: URI): Promise<Result<URI>>;
+    buildUrl({ loader: { sthis } }: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<URI>>;
+    close({ loader: { sthis } }: SerdeGatewayCtx, uri: URI): Promise<Result<void>>;
+    private subscribeFn;
+    put<T>({ loader: { sthis }, encoder }: SerdeGatewayCtx, url: URI, env: FPEnvelope<T>): Promise<Result<void>>;
+    get<S>({ loader: { sthis }, decoder }: SerdeGatewayCtx, url: URI): Promise<SerdeGetResult<S>>;
+    subscribe({ loader: { sthis }, decoder }: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<Result<() => void>>;
+    delete({ loader: { sthis } }: SerdeGatewayCtx, url: URI): Promise<Result<void>>;
+    destroy({ loader: { sthis } }: SerdeGatewayCtx, baseURL: URI): Promise<Result<void>>;
+    getPlain({ loader: { sthis } }: SerdeGatewayCtx, iurl: URI, key: string): Promise<Result<Uint8Array<ArrayBufferLike>, Error>>;
+}
+
+type index$3_CARDecodeEnvelope = CARDecodeEnvelope;
+type index$3_CAREncodeEnvelope = CAREncodeEnvelope;
+type index$3_DefSerdeGateway = DefSerdeGateway;
+declare const index$3_DefSerdeGateway: typeof DefSerdeGateway;
+type index$3_FILEDecodeEnvelope = FILEDecodeEnvelope;
+type index$3_FILEEncodeEnvelope = FILEEncodeEnvelope;
+type index$3_FPDecoder = FPDecoder;
+type index$3_FPEncoder = FPEncoder;
+type index$3_METADecodeEnvelope = METADecodeEnvelope;
+type index$3_METAEncodeEnvelope = METAEncodeEnvelope;
+type index$3_SerializedMeta = SerializedMeta;
+type index$3_SerializedWAL = SerializedWAL;
+type index$3_WALDecodeEnvelope = WALDecodeEnvelope;
+type index$3_WALEncodeEnvelope = WALEncodeEnvelope;
+declare const index$3_dbMetaEvent2Serialized: typeof dbMetaEvent2Serialized;
+declare const index$3_decode2DbMetaEvents: typeof decode2DbMetaEvents;
+declare const index$3_fpDeserialize: typeof fpDeserialize;
+declare const index$3_fpSerialize: typeof fpSerialize;
+declare namespace index$3 {
+  export { type index$3_CARDecodeEnvelope as CARDecodeEnvelope, type index$3_CAREncodeEnvelope as CAREncodeEnvelope, index$3_DefSerdeGateway as DefSerdeGateway, type index$3_FILEDecodeEnvelope as FILEDecodeEnvelope, type index$3_FILEEncodeEnvelope as FILEEncodeEnvelope, type index$3_FPDecoder as FPDecoder, type index$3_FPEncoder as FPEncoder, type index$3_METADecodeEnvelope as METADecodeEnvelope, type index$3_METAEncodeEnvelope as METAEncodeEnvelope, type index$3_SerializedMeta as SerializedMeta, type index$3_SerializedWAL as SerializedWAL, type index$3_WALDecodeEnvelope as WALDecodeEnvelope, type index$3_WALEncodeEnvelope as WALEncodeEnvelope, gateway as cloud, index$3_dbMetaEvent2Serialized as dbMetaEvent2Serialized, index$3_decode2DbMetaEvents as decode2DbMetaEvents, index$4 as file, index$3_fpDeserialize as fpDeserialize, index$3_fpSerialize as fpSerialize, gateway$1 as memory };
+}
+
+type V1SerializedMetaKey = SerializedMeta & {
+    readonly key?: string | string[];
+    readonly keys?: string[];
+};
+interface V2SerializedMetaKey {
+    readonly metas: SerializedMeta[];
+    readonly keys: string[];
+}
+declare function V2SerializedMetaKeyExtractKey(ctx: SerdeGatewayCtx, v2: V2SerializedMetaKey): Promise<Result<SerializedMeta[]>>;
+declare function decodeAsToSerializedMeta(ctx: SerdeGatewayCtx, raw: Uint8Array): Promise<Result<V2SerializedMetaKey>>;
+declare function addKeyToDbMetaDecoder(ctx: SerdeGatewayCtx & {
+    readonly lastDecodedMetas?: V2SerializedMetaKey[];
+}): SerdeGatewayCtx & {
+    lastDecodedMetas: V2SerializedMetaKey[];
+};
+declare function encodeAsV1SerializedMetaKey(ctx: SerdeGatewayCtx, payload: SerializedMeta[]): Promise<Result<V1SerializedMetaKey[]>>;
+declare function encodeAsV2SerializedMetaKey(ctx: SerdeGatewayCtx, payload: SerializedMeta[]): Promise<Result<V2SerializedMetaKey>>;
+declare function addKeyToDbMetaEncoder(ctx: SerdeGatewayCtx, version: "v1" | "v2"): SerdeGatewayCtx;
+declare class AddKeyToDbMetaGateway implements SerdeGateway {
+    private readonly sdGw;
+    readonly version: "v1" | "v2";
+    constructor(gw: Gateway, version: "v1" | "v2");
+    buildUrl(ctx: SerdeGatewayCtx, baseUrl: URI, key: string): Promise<Result<URI>>;
+    start(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<URI>>;
+    close(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<void, Error>>;
+    put<T>(ctx: SerdeGatewayCtx, url: URI, body: FPEnvelope<T>): Promise<Result<void, Error>>;
+    get<S>(ctx: SerdeGatewayCtx, url: URI): Promise<Result<FPEnvelope<S>, Error | NotFoundError>>;
+    readonly lastDecodedMetas: V2SerializedMetaKey[];
+    delete(ctx: SerdeGatewayCtx, url: URI, loader?: Loadable): Promise<Result<void, Error>>;
+    subscribe(ctx: SerdeGatewayCtx, url: URI, callback: (meta: FPEnvelopeMeta) => Promise<void>): Promise<Result<() => void, Error>>;
+    getPlain(ctx: SerdeGatewayCtx, url: URI, key: string): Promise<Result<Uint8Array>>;
+    destroy(ctx: SerdeGatewayCtx, baseUrl: URI): Promise<Result<void, Error>>;
+}
+
+declare const FILESTORE_VERSION = "v0.19-file";
+
+declare const INDEXEDDB_VERSION = "v0.19-indexeddb";
+
+type index$2_AddKeyToDbMetaGateway = AddKeyToDbMetaGateway;
+declare const index$2_AddKeyToDbMetaGateway: typeof AddKeyToDbMetaGateway;
+declare const index$2_FILESTORE_VERSION: typeof FILESTORE_VERSION;
+declare const index$2_INDEXEDDB_VERSION: typeof INDEXEDDB_VERSION;
+type index$2_KeyBackProviderFactory = KeyBackProviderFactory;
+type index$2_KeyBag = KeyBag;
+declare const index$2_KeyBag: typeof KeyBag;
+type index$2_KeyBagFile = KeyBagFile;
+type index$2_KeyBagOpts = KeyBagOpts;
+type index$2_KeyBagProvider = KeyBagProvider;
+type index$2_KeyBagProviderFactoryItem = KeyBagProviderFactoryItem;
+type index$2_KeyBagRuntime = KeyBagRuntime;
+type index$2_KeysItem = KeysItem;
+type index$2_V1StorageKeyItem = V1StorageKeyItem;
+type index$2_V2SerializedMetaKey = V2SerializedMetaKey;
+declare const index$2_V2SerializedMetaKeyExtractKey: typeof V2SerializedMetaKeyExtractKey;
+type index$2_V2StorageKeyItem = V2StorageKeyItem;
+declare const index$2_addKeyToDbMetaDecoder: typeof addKeyToDbMetaDecoder;
+declare const index$2_addKeyToDbMetaEncoder: typeof addKeyToDbMetaEncoder;
+declare const index$2_decodeAsToSerializedMeta: typeof decodeAsToSerializedMeta;
+declare const index$2_defaultKeyBagOpts: typeof defaultKeyBagOpts;
+declare const index$2_defaultKeyBagUrl: typeof defaultKeyBagUrl;
+declare const index$2_encodeAsV1SerializedMetaKey: typeof encodeAsV1SerializedMetaKey;
+declare const index$2_encodeAsV2SerializedMetaKey: typeof encodeAsV2SerializedMetaKey;
+declare const index$2_files: typeof files;
+declare const index$2_getFileName: typeof getFileName;
+declare const index$2_getKeyBag: typeof getKeyBag;
+declare const index$2_getPath: typeof getPath;
+type index$2_keysByFingerprint = keysByFingerprint;
+declare const index$2_keysByFingerprint: typeof keysByFingerprint;
+declare const index$2_registerKeyBagProviderFactory: typeof registerKeyBagProviderFactory;
+declare const index$2_runtimeFn: typeof runtimeFn;
+declare const index$2_toKeyWithFingerPrint: typeof toKeyWithFingerPrint;
+declare namespace index$2 {
+  export { index$2_AddKeyToDbMetaGateway as AddKeyToDbMetaGateway, index$2_FILESTORE_VERSION as FILESTORE_VERSION, index$2_INDEXEDDB_VERSION as INDEXEDDB_VERSION, type index$2_KeyBackProviderFactory as KeyBackProviderFactory, index$2_KeyBag as KeyBag, type index$2_KeyBagFile as KeyBagFile, type index$2_KeyBagOpts as KeyBagOpts, type index$2_KeyBagProvider as KeyBagProvider, type index$2_KeyBagProviderFactoryItem as KeyBagProviderFactoryItem, type index$2_KeyBagRuntime as KeyBagRuntime, type index$2_KeysItem as KeysItem, type index$2_V1StorageKeyItem as V1StorageKeyItem, type index$2_V2SerializedMetaKey as V2SerializedMetaKey, index$2_V2SerializedMetaKeyExtractKey as V2SerializedMetaKeyExtractKey, type index$2_V2StorageKeyItem as V2StorageKeyItem, index$2_addKeyToDbMetaDecoder as addKeyToDbMetaDecoder, index$2_addKeyToDbMetaEncoder as addKeyToDbMetaEncoder, index$2_decodeAsToSerializedMeta as decodeAsToSerializedMeta, index$2_defaultKeyBagOpts as defaultKeyBagOpts, index$2_defaultKeyBagUrl as defaultKeyBagUrl, index$2_encodeAsV1SerializedMetaKey as encodeAsV1SerializedMetaKey, index$2_encodeAsV2SerializedMetaKey as encodeAsV2SerializedMetaKey, index$2_files as files, index$2_getFileName as getFileName, index$2_getKeyBag as getKeyBag, index$2_getPath as getPath, index$3 as gw, keyBag as kb, keyedCrypto as kc, index$2_keysByFingerprint as keysByFingerprint, index$6 as mf, index$2_registerKeyBagProviderFactory as registerKeyBagProviderFactory, index$2_runtimeFn as runtimeFn, index$5 as sts, index$2_toKeyWithFingerPrint as toKeyWithFingerPrint };
+}
+
+declare class MsgRawConnectionBase {
+    readonly sthis: SuperThis;
+    readonly exchangedGestalt: ExchangedGestalt;
+    constructor(sthis: SuperThis, exGestalt: ExchangedGestalt);
+    readonly onErrorFns: Map<string, OnErrorFn>;
+    onError(fn: OnErrorFn): UnReg;
+    buildErrorMsg(msgCtx: {
+        readonly logger: Logger;
+        readonly sthis: SuperThis;
+    }, msg: Partial<MsgBase>, err: Error): ErrorMsg;
+}
+
+declare function ensurePath(uri: URI, fp: string): string;
+declare class HttpConnection extends MsgRawConnectionBase implements MsgRawConnection {
+    #private;
+    readonly logger: Logger;
+    readonly msgP: MsgerParamsWithEnDe;
+    readonly baseURIs: {
+        in: URI;
+        cleaned: URI;
+    }[];
+    constructor(sthis: SuperThis, uris: URI[], msgP: MsgerParamsWithEnDe, exGestalt: ExchangedGestalt);
+    send<S extends MsgBase, Q extends MsgBase>(_msg: Q): Promise<MsgWithError<S>>;
+    start(): Promise<Result<void>>;
+    close(): Promise<Result<void>>;
+    toMsg<S extends MsgBase>(msg: MsgWithError<S>): MsgWithError<S>;
+    onMsg(fn: OnMsgFn): UnReg;
+    readonly activeBinds: Map<string, ActiveStream<MsgBase, MsgBase>>;
+    bind<Q extends MsgBase, S extends MsgBase>(req: Q, opts: RequestOpts): ReadableStream<MsgWithError<S>>;
+    request<Q extends MsgBase, S extends MsgBase>(req: Q, _opts: RequestOpts): Promise<MsgWithError<S>>;
+}
+
+interface ReqPutMeta extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly type: "reqPutMeta";
+    readonly methodParams: MethodSignedUrlParam;
+    readonly params: SignedUrlParam;
+    readonly meta: V2SerializedMetaKey;
+}
+interface ResPutMeta extends MsgWithTenantLedger<MsgWithConnAuth>, ResSignedUrl {
+    readonly type: "resPutMeta";
+    readonly meta: V2SerializedMetaKey;
+}
+declare function buildReqPutMeta(sthis: NextId, auth: AuthType, signedUrlParams: SignedUrlParam, meta: V2SerializedMetaKey, gwCtx: GwCtx): ReqPutMeta;
+declare function MsgIsReqPutMeta(msg: MsgBase): msg is ReqPutMeta;
+declare function buildResPutMeta(_msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<ReqPutMeta>>, meta: V2SerializedMetaKey, signedUrl: string): ResPutMeta;
+declare function MsgIsResPutMeta(qs: MsgBase): qs is ResPutMeta;
+interface BindGetMeta extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly type: "bindGetMeta";
+    readonly params: SignedUrlParam;
+}
+declare function MsgIsBindGetMeta(msg: MsgBase): msg is BindGetMeta;
+interface EventGetMeta extends MsgWithTenantLedger<MsgWithConnAuth>, ResSignedUrl {
+    readonly type: "eventGetMeta";
+    readonly meta: V2SerializedMetaKey;
+}
+declare function buildBindGetMeta(sthis: NextId, auth: AuthType, params: SignedUrlParam, gwCtx: GwCtx): BindGetMeta;
+declare function buildEventGetMeta(_msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<BindGetMeta>>, meta: V2SerializedMetaKey, gwCtx: GwCtx, signedUrl: string): EventGetMeta;
+declare function MsgIsEventGetMeta(qs: MsgBase): qs is EventGetMeta;
+interface ReqDelMeta extends MsgWithTenantLedger<MsgWithConnAuth> {
+    readonly type: "reqDelMeta";
+    readonly params: SignedUrlParam;
+    readonly meta?: V2SerializedMetaKey;
+}
+declare function buildReqDelMeta(sthis: NextId, auth: AuthType, params: SignedUrlParam, gwCtx: GwCtx, meta?: V2SerializedMetaKey): ReqDelMeta;
+declare function MsgIsReqDelMeta(msg: MsgBase): msg is ReqDelMeta;
+interface ResDelMeta extends MsgWithTenantLedger<MsgWithConnAuth>, ResOptionalSignedUrl {
+    readonly type: "resDelMeta";
+}
+declare function buildResDelMeta(req: MsgWithTenantLedger<MsgWithConnAuth<ReqDelMeta>>, params: SignedUrlParam, signedUrl?: string): ResDelMeta;
+declare function MsgIsResDelMeta(qs: MsgBase): qs is ResDelMeta;
+
+interface ReqGetWAL extends ReqSignedUrl {
+    readonly type: "reqGetWAL";
+}
+declare function MsgIsReqGetWAL(msg: MsgBase): msg is ReqGetWAL;
+declare function buildReqGetWAL(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqGetWAL;
+interface ResGetWAL extends ResSignedUrl {
+    readonly type: "resGetWAL";
+}
+declare function MsgIsResGetWAL(msg: MsgBase): msg is ResGetWAL;
+declare function buildResGetWAL(msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<ReqGetWAL>>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResGetWAL>>;
+interface ReqPutWAL extends Omit<ReqSignedUrl, "type"> {
+    readonly type: "reqPutWAL";
+}
+declare function MsgIsReqPutWAL(msg: MsgBase): msg is ReqPutWAL;
+declare function buildReqPutWAL(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqPutWAL;
+interface ResPutWAL extends Omit<ResSignedUrl, "type"> {
+    readonly type: "resPutWAL";
+}
+declare function MsgIsResPutWAL(msg: MsgBase): msg is ResPutWAL;
+declare function buildResPutWAL(msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<ReqPutWAL>>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResPutWAL>>;
+interface ReqDelWAL extends Omit<ReqSignedUrl, "type"> {
+    readonly type: "reqDelWAL";
+}
+declare function MsgIsReqDelWAL(msg: MsgBase): msg is ReqDelWAL;
+declare function buildReqDelWAL(sthis: NextId, sup: ReqSignedUrlParam, ctx: GwCtx): ReqDelWAL;
+interface ResDelWAL extends Omit<ResSignedUrl, "type"> {
+    readonly type: "resDelWAL";
+}
+declare function MsgIsResDelWAL(msg: MsgBase): msg is ResDelWAL;
+declare function buildResDelWAL(msgCtx: MsgTypesCtx, req: MsgWithTenantLedger<MsgWithConnAuth<ReqDelWAL>>, ctx: CalculatePreSignedUrl): Promise<MsgWithError<ResDelWAL>>;
+
+interface WSReqOpen {
+    readonly reqOpen: ReqOpen;
+    readonly ws: WebSocket;
+}
+declare class WSConnection extends MsgRawConnectionBase implements MsgRawConnection {
+    #private;
+    readonly logger: Logger;
+    readonly msgP: MsgerParamsWithEnDe;
+    readonly ws: WebSocket;
+    readonly waitForTid: Map<string, WaitForTid>;
+    opened: boolean;
+    readonly id: string;
+    constructor(sthis: SuperThis, ws: WebSocket, msgP: MsgerParamsWithEnDe, exGestalt: ExchangedGestalt);
+    start(): Promise<Result<void>>;
+    close(): Promise<Result<void>>;
+    toMsg<S extends MsgBase>(msg: MsgWithError<S>): MsgWithError<S>;
+    send<Q extends MsgBase, S extends MsgBase>(msg: Q): Promise<S>;
+    onMsg<S extends MsgBase>(fn: OnMsgFn<S>): UnReg;
+    onClose(fn: UnReg): UnReg;
+    readonly activeBinds: Map<string, ActiveStream<MsgBase, MsgBase>>;
+    bind<Q extends MsgBase, S extends MsgBase>(req: Q, opts: RequestOpts): ReadableStream<MsgWithError<S>>;
+    request<Q extends MsgBase, S extends MsgBase>(req: Q, opts: RequestOpts): Promise<MsgWithError<S>>;
+}
+
+type index$1_ActiveStream<S extends MsgBase, Q extends MsgBase> = ActiveStream<S, Q>;
+type index$1_AuthFactory = AuthFactory;
+type index$1_AuthType = AuthType;
+type index$1_BaseTokenParam = BaseTokenParam;
+type index$1_BindGetMeta = BindGetMeta;
+type index$1_CalculatePreSignedUrl = CalculatePreSignedUrl;
+type index$1_ConnInfo = ConnInfo;
+type index$1_EnDeCoder = EnDeCoder;
+type index$1_ErrorMsg = ErrorMsg;
+type index$1_EventGetMeta = EventGetMeta;
+type index$1_ExchangedGestalt = ExchangedGestalt;
+type index$1_FPCloudAuthType = FPCloudAuthType;
+type index$1_FPCloudClaim = FPCloudClaim;
+type index$1_FPJWKCloudAuthType = FPJWKCloudAuthType;
+type index$1_FPStoreTypes = FPStoreTypes;
+type index$1_Gestalt = Gestalt;
+type index$1_GestaltParam = GestaltParam;
+type index$1_GwCtx = GwCtx;
+type index$1_GwCtxConn = GwCtxConn;
+type index$1_HttpConnection = HttpConnection;
+declare const index$1_HttpConnection: typeof HttpConnection;
+type index$1_HttpMethods = HttpMethods;
+type index$1_MethodSignedUrlParam = MethodSignedUrlParam;
+type index$1_MsgBase = MsgBase;
+type index$1_MsgConnected = MsgConnected;
+declare const index$1_MsgConnected: typeof MsgConnected;
+type index$1_MsgConnectedAuth = MsgConnectedAuth;
+declare const index$1_MsgConnectedAuth: typeof MsgConnectedAuth;
+declare const index$1_MsgIsBindGetMeta: typeof MsgIsBindGetMeta;
+declare const index$1_MsgIsConnected: typeof MsgIsConnected;
+declare const index$1_MsgIsError: typeof MsgIsError;
+declare const index$1_MsgIsEventGetMeta: typeof MsgIsEventGetMeta;
+declare const index$1_MsgIsQSError: typeof MsgIsQSError;
+declare const index$1_MsgIsReqChat: typeof MsgIsReqChat;
+declare const index$1_MsgIsReqClose: typeof MsgIsReqClose;
+declare const index$1_MsgIsReqDelData: typeof MsgIsReqDelData;
+declare const index$1_MsgIsReqDelMeta: typeof MsgIsReqDelMeta;
+declare const index$1_MsgIsReqDelWAL: typeof MsgIsReqDelWAL;
+declare const index$1_MsgIsReqGestalt: typeof MsgIsReqGestalt;
+declare const index$1_MsgIsReqGetData: typeof MsgIsReqGetData;
+declare const index$1_MsgIsReqGetWAL: typeof MsgIsReqGetWAL;
+declare const index$1_MsgIsReqOpen: typeof MsgIsReqOpen;
+declare const index$1_MsgIsReqPutData: typeof MsgIsReqPutData;
+declare const index$1_MsgIsReqPutMeta: typeof MsgIsReqPutMeta;
+declare const index$1_MsgIsReqPutWAL: typeof MsgIsReqPutWAL;
+declare const index$1_MsgIsResChat: typeof MsgIsResChat;
+declare const index$1_MsgIsResClose: typeof MsgIsResClose;
+declare const index$1_MsgIsResDelData: typeof MsgIsResDelData;
+declare const index$1_MsgIsResDelMeta: typeof MsgIsResDelMeta;
+declare const index$1_MsgIsResDelWAL: typeof MsgIsResDelWAL;
+declare const index$1_MsgIsResGestalt: typeof MsgIsResGestalt;
+declare const index$1_MsgIsResGetData: typeof MsgIsResGetData;
+declare const index$1_MsgIsResGetWAL: typeof MsgIsResGetWAL;
+declare const index$1_MsgIsResOpen: typeof MsgIsResOpen;
+declare const index$1_MsgIsResPutData: typeof MsgIsResPutData;
+declare const index$1_MsgIsResPutMeta: typeof MsgIsResPutMeta;
+declare const index$1_MsgIsResPutWAL: typeof MsgIsResPutWAL;
+declare const index$1_MsgIsTenantLedger: typeof MsgIsTenantLedger;
+declare const index$1_MsgIsTid: typeof MsgIsTid;
+declare const index$1_MsgIsWithConn: typeof MsgIsWithConn;
+declare const index$1_MsgIsWithConnAuth: typeof MsgIsWithConnAuth;
+type index$1_MsgRawConnection<T extends MsgBase = MsgBase> = MsgRawConnection<T>;
+type index$1_MsgRawConnectionBase = MsgRawConnectionBase;
+declare const index$1_MsgRawConnectionBase: typeof MsgRawConnectionBase;
+type index$1_MsgTypesCtx = MsgTypesCtx;
+type index$1_MsgTypesCtxSync = MsgTypesCtxSync;
+type index$1_MsgWithConnAuth<T extends MsgBase = MsgBase> = MsgWithConnAuth<T>;
+type index$1_MsgWithError<T extends MsgBase> = MsgWithError<T>;
+type index$1_MsgWithTenantLedger<T extends MsgWithConnAuth> = MsgWithTenantLedger<T>;
+type index$1_Msger = Msger;
+declare const index$1_Msger: typeof Msger;
+type index$1_MsgerParams = MsgerParams;
+type index$1_MsgerParamsWithEnDe = MsgerParamsWithEnDe;
+type index$1_NextId = NextId;
+type index$1_OnErrorFn = OnErrorFn;
+type index$1_OnMsgFn<T extends MsgBase = MsgBase> = OnMsgFn<T>;
+type index$1_OpenParams = OpenParams;
+type index$1_PreSignedMsg = PreSignedMsg;
+type index$1_ProtocolCapabilities = ProtocolCapabilities;
+type index$1_QSId = QSId;
+type index$1_ReqChat = ReqChat;
+type index$1_ReqClose = ReqClose;
+type index$1_ReqDelData = ReqDelData;
+type index$1_ReqDelMeta = ReqDelMeta;
+type index$1_ReqDelWAL = ReqDelWAL;
+type index$1_ReqGestalt = ReqGestalt;
+type index$1_ReqGetData = ReqGetData;
+type index$1_ReqGetWAL = ReqGetWAL;
+type index$1_ReqOpen = ReqOpen;
+type index$1_ReqOpenConn = ReqOpenConn;
+type index$1_ReqOpenConnection = ReqOpenConnection;
+type index$1_ReqPutData = ReqPutData;
+type index$1_ReqPutMeta = ReqPutMeta;
+type index$1_ReqPutWAL = ReqPutWAL;
+type index$1_ReqRes<Q extends MsgBase, S extends MsgBase> = ReqRes<Q, S>;
+type index$1_ReqSignedUrl = ReqSignedUrl;
+type index$1_ReqSignedUrlParam = ReqSignedUrlParam;
+type index$1_ReqSignedUrlWithoutMethodParams = ReqSignedUrlWithoutMethodParams;
+type index$1_RequestOpts = RequestOpts;
+type index$1_ResChat = ResChat;
+type index$1_ResClose = ResClose;
+type index$1_ResDelData = ResDelData;
+type index$1_ResDelMeta = ResDelMeta;
+type index$1_ResDelWAL = ResDelWAL;
+type index$1_ResGestalt = ResGestalt;
+type index$1_ResGetData = ResGetData;
+type index$1_ResGetWAL = ResGetWAL;
+type index$1_ResOpen = ResOpen;
+type index$1_ResOptionalSignedUrl = ResOptionalSignedUrl;
+type index$1_ResPutData = ResPutData;
+type index$1_ResPutMeta = ResPutMeta;
+type index$1_ResPutWAL = ResPutWAL;
+type index$1_ResSignedUrl = ResSignedUrl;
+type index$1_SignedUrlParam = SignedUrlParam;
+type index$1_TenantLedger = TenantLedger;
+type index$1_TokenForParam = TokenForParam;
+type index$1_UCanAuth = UCanAuth;
+type index$1_UnReg = UnReg;
+type index$1_UpdateReqRes<Q extends MsgBase, S extends MsgBase> = UpdateReqRes<Q, S>;
+declare const index$1_VERSION: typeof VERSION;
+type index$1_WSConnection = WSConnection;
+declare const index$1_WSConnection: typeof WSConnection;
+type index$1_WSReqOpen = WSReqOpen;
+type index$1_WaitForTid = WaitForTid;
+declare const index$1_applyStart: typeof applyStart;
+declare const index$1_authTypeFromUri: typeof authTypeFromUri;
+declare const index$1_buildBindGetMeta: typeof buildBindGetMeta;
+declare const index$1_buildErrorMsg: typeof buildErrorMsg;
+declare const index$1_buildEventGetMeta: typeof buildEventGetMeta;
+declare const index$1_buildReqChat: typeof buildReqChat;
+declare const index$1_buildReqClose: typeof buildReqClose;
+declare const index$1_buildReqDelData: typeof buildReqDelData;
+declare const index$1_buildReqDelMeta: typeof buildReqDelMeta;
+declare const index$1_buildReqDelWAL: typeof buildReqDelWAL;
+declare const index$1_buildReqGestalt: typeof buildReqGestalt;
+declare const index$1_buildReqGetData: typeof buildReqGetData;
+declare const index$1_buildReqGetWAL: typeof buildReqGetWAL;
+declare const index$1_buildReqOpen: typeof buildReqOpen;
+declare const index$1_buildReqPutData: typeof buildReqPutData;
+declare const index$1_buildReqPutMeta: typeof buildReqPutMeta;
+declare const index$1_buildReqPutWAL: typeof buildReqPutWAL;
+declare const index$1_buildReqSignedUrl: typeof buildReqSignedUrl;
+declare const index$1_buildRes: typeof buildRes;
+declare const index$1_buildResChat: typeof buildResChat;
+declare const index$1_buildResClose: typeof buildResClose;
+declare const index$1_buildResDelData: typeof buildResDelData;
+declare const index$1_buildResDelMeta: typeof buildResDelMeta;
+declare const index$1_buildResDelWAL: typeof buildResDelWAL;
+declare const index$1_buildResGestalt: typeof buildResGestalt;
+declare const index$1_buildResGetData: typeof buildResGetData;
+declare const index$1_buildResGetWAL: typeof buildResGetWAL;
+declare const index$1_buildResOpen: typeof buildResOpen;
+declare const index$1_buildResPutData: typeof buildResPutData;
+declare const index$1_buildResPutMeta: typeof buildResPutMeta;
+declare const index$1_buildResPutWAL: typeof buildResPutWAL;
+declare const index$1_coerceFPStoreTypes: typeof coerceFPStoreTypes;
+declare const index$1_defaultGestalt: typeof defaultGestalt;
+declare const index$1_defaultMsgParams: typeof defaultMsgParams;
+declare const index$1_ensurePath: typeof ensurePath;
+declare const index$1_isAuthTypeFPCloud: typeof isAuthTypeFPCloud;
+declare const index$1_isAuthTypeFPCloudJWK: typeof isAuthTypeFPCloudJWK;
+declare const index$1_isProtocolCapabilities: typeof isProtocolCapabilities;
+declare const index$1_jsonEnDe: typeof jsonEnDe;
+declare const index$1_keyTenantLedger: typeof keyTenantLedger;
+declare const index$1_qsidEqual: typeof qsidEqual;
+declare const index$1_qsidKey: typeof qsidKey;
+declare const index$1_resAuth: typeof resAuth;
+declare const index$1_selectRandom: typeof selectRandom;
+declare const index$1_timeout: typeof timeout;
+declare namespace index$1 {
+  export { type index$1_ActiveStream as ActiveStream, type index$1_AuthFactory as AuthFactory, type index$1_AuthType as AuthType, type index$1_BaseTokenParam as BaseTokenParam, type index$1_BindGetMeta as BindGetMeta, type index$1_CalculatePreSignedUrl as CalculatePreSignedUrl, type index$1_ConnInfo as ConnInfo, type index$1_EnDeCoder as EnDeCoder, type index$1_ErrorMsg as ErrorMsg, type index$1_EventGetMeta as EventGetMeta, type index$1_ExchangedGestalt as ExchangedGestalt, type index$1_FPCloudAuthType as FPCloudAuthType, type index$1_FPCloudClaim as FPCloudClaim, type index$1_FPJWKCloudAuthType as FPJWKCloudAuthType, type index$1_FPStoreTypes as FPStoreTypes, type index$1_Gestalt as Gestalt, type index$1_GestaltParam as GestaltParam, type index$1_GwCtx as GwCtx, type index$1_GwCtxConn as GwCtxConn, index$1_HttpConnection as HttpConnection, type index$1_HttpMethods as HttpMethods, type index$1_MethodSignedUrlParam as MethodSignedUrlParam, type index$1_MsgBase as MsgBase, index$1_MsgConnected as MsgConnected, index$1_MsgConnectedAuth as MsgConnectedAuth, index$1_MsgIsBindGetMeta as MsgIsBindGetMeta, index$1_MsgIsConnected as MsgIsConnected, index$1_MsgIsError as MsgIsError, index$1_MsgIsEventGetMeta as MsgIsEventGetMeta, index$1_MsgIsQSError as MsgIsQSError, index$1_MsgIsReqChat as MsgIsReqChat, index$1_MsgIsReqClose as MsgIsReqClose, index$1_MsgIsReqDelData as MsgIsReqDelData, index$1_MsgIsReqDelMeta as MsgIsReqDelMeta, index$1_MsgIsReqDelWAL as MsgIsReqDelWAL, index$1_MsgIsReqGestalt as MsgIsReqGestalt, index$1_MsgIsReqGetData as MsgIsReqGetData, index$1_MsgIsReqGetWAL as MsgIsReqGetWAL, index$1_MsgIsReqOpen as MsgIsReqOpen, index$1_MsgIsReqPutData as MsgIsReqPutData, index$1_MsgIsReqPutMeta as MsgIsReqPutMeta, index$1_MsgIsReqPutWAL as MsgIsReqPutWAL, index$1_MsgIsResChat as MsgIsResChat, index$1_MsgIsResClose as MsgIsResClose, index$1_MsgIsResDelData as MsgIsResDelData, index$1_MsgIsResDelMeta as MsgIsResDelMeta, index$1_MsgIsResDelWAL as MsgIsResDelWAL, index$1_MsgIsResGestalt as MsgIsResGestalt, index$1_MsgIsResGetData as MsgIsResGetData, index$1_MsgIsResGetWAL as MsgIsResGetWAL, index$1_MsgIsResOpen as MsgIsResOpen, index$1_MsgIsResPutData as MsgIsResPutData, index$1_MsgIsResPutMeta as MsgIsResPutMeta, index$1_MsgIsResPutWAL as MsgIsResPutWAL, index$1_MsgIsTenantLedger as MsgIsTenantLedger, index$1_MsgIsTid as MsgIsTid, index$1_MsgIsWithConn as MsgIsWithConn, index$1_MsgIsWithConnAuth as MsgIsWithConnAuth, type index$1_MsgRawConnection as MsgRawConnection, index$1_MsgRawConnectionBase as MsgRawConnectionBase, type index$1_MsgTypesCtx as MsgTypesCtx, type index$1_MsgTypesCtxSync as MsgTypesCtxSync, type index$1_MsgWithConnAuth as MsgWithConnAuth, type index$1_MsgWithError as MsgWithError, type index$1_MsgWithTenantLedger as MsgWithTenantLedger, index$1_Msger as Msger, type index$1_MsgerParams as MsgerParams, type index$1_MsgerParamsWithEnDe as MsgerParamsWithEnDe, type index$1_NextId as NextId, type index$1_OnErrorFn as OnErrorFn, type index$1_OnMsgFn as OnMsgFn, type index$1_OpenParams as OpenParams, type index$1_PreSignedMsg as PreSignedMsg, type index$1_ProtocolCapabilities as ProtocolCapabilities, type index$1_QSId as QSId, type index$1_ReqChat as ReqChat, type index$1_ReqClose as ReqClose, type index$1_ReqDelData as ReqDelData, type index$1_ReqDelMeta as ReqDelMeta, type index$1_ReqDelWAL as ReqDelWAL, type index$1_ReqGestalt as ReqGestalt, type index$1_ReqGetData as ReqGetData, type index$1_ReqGetWAL as ReqGetWAL, type index$1_ReqOpen as ReqOpen, type index$1_ReqOpenConn as ReqOpenConn, type index$1_ReqOpenConnection as ReqOpenConnection, type index$1_ReqPutData as ReqPutData, type index$1_ReqPutMeta as ReqPutMeta, type index$1_ReqPutWAL as ReqPutWAL, type index$1_ReqRes as ReqRes, type index$1_ReqSignedUrl as ReqSignedUrl, type index$1_ReqSignedUrlParam as ReqSignedUrlParam, type index$1_ReqSignedUrlWithoutMethodParams as ReqSignedUrlWithoutMethodParams, type index$1_RequestOpts as RequestOpts, type index$1_ResChat as ResChat, type index$1_ResClose as ResClose, type index$1_ResDelData as ResDelData, type index$1_ResDelMeta as ResDelMeta, type index$1_ResDelWAL as ResDelWAL, type index$1_ResGestalt as ResGestalt, type index$1_ResGetData as ResGetData, type index$1_ResGetWAL as ResGetWAL, type index$1_ResOpen as ResOpen, type index$1_ResOptionalSignedUrl as ResOptionalSignedUrl, type index$1_ResPutData as ResPutData, type index$1_ResPutMeta as ResPutMeta, type index$1_ResPutWAL as ResPutWAL, type index$1_ResSignedUrl as ResSignedUrl, type index$1_SignedUrlParam as SignedUrlParam, type index$1_TenantLedger as TenantLedger, type index$1_TokenForParam as TokenForParam, type index$1_UCanAuth as UCanAuth, type index$1_UnReg as UnReg, type index$1_UpdateReqRes as UpdateReqRes, index$1_VERSION as VERSION, index$1_WSConnection as WSConnection, type index$1_WSReqOpen as WSReqOpen, type index$1_WaitForTid as WaitForTid, index$1_applyStart as applyStart, index$1_authTypeFromUri as authTypeFromUri, index$1_buildBindGetMeta as buildBindGetMeta, index$1_buildErrorMsg as buildErrorMsg, index$1_buildEventGetMeta as buildEventGetMeta, index$1_buildReqChat as buildReqChat, index$1_buildReqClose as buildReqClose, index$1_buildReqDelData as buildReqDelData, index$1_buildReqDelMeta as buildReqDelMeta, index$1_buildReqDelWAL as buildReqDelWAL, index$1_buildReqGestalt as buildReqGestalt, index$1_buildReqGetData as buildReqGetData, index$1_buildReqGetWAL as buildReqGetWAL, index$1_buildReqOpen as buildReqOpen, index$1_buildReqPutData as buildReqPutData, index$1_buildReqPutMeta as buildReqPutMeta, index$1_buildReqPutWAL as buildReqPutWAL, index$1_buildReqSignedUrl as buildReqSignedUrl, index$1_buildRes as buildRes, index$1_buildResChat as buildResChat, index$1_buildResClose as buildResClose, index$1_buildResDelData as buildResDelData, index$1_buildResDelMeta as buildResDelMeta, index$1_buildResDelWAL as buildResDelWAL, index$1_buildResGestalt as buildResGestalt, index$1_buildResGetData as buildResGetData, index$1_buildResGetWAL as buildResGetWAL, index$1_buildResOpen as buildResOpen, index$1_buildResPutData as buildResPutData, index$1_buildResPutMeta as buildResPutMeta, index$1_buildResPutWAL as buildResPutWAL, index$1_coerceFPStoreTypes as coerceFPStoreTypes, index$1_defaultGestalt as defaultGestalt, index$1_defaultMsgParams as defaultMsgParams, index$1_ensurePath as ensurePath, index$1_isAuthTypeFPCloud as isAuthTypeFPCloud, index$1_isAuthTypeFPCloudJWK as isAuthTypeFPCloudJWK, index$1_isProtocolCapabilities as isProtocolCapabilities, index$1_jsonEnDe as jsonEnDe, index$1_keyTenantLedger as keyTenantLedger, index$1_qsidEqual as qsidEqual, index$1_qsidKey as qsidKey, index$1_resAuth as resAuth, index$1_selectRandom as selectRandom, index$1_timeout as timeout };
+}
+
+declare namespace index {
+  export { index$1 as cloud };
+}
+
+declare const PACKAGE_VERSION: string;
+
+export { type AllDocsQueryOpts, type AllDocsResponse, type Attachable, type Attached, type BaseBlockstore, type BulkResponse, type CRDT, type CRDTClock, type CRDTEntry, CRDTImpl, type CRDTMeta, type CarTransaction, type ChangesOptions, type ChangesResponse, type ChangesResponseRow, type ClockHead, type ClockLink, type CoerceURIandInterceptor, type ConfigOpts, DataAndMetaAndWalAndBaseStore, type Database, DatabaseImpl, type DbMeta, type DocBase, type DocFileMeta, type DocFiles, type DocFragment, type DocLiteral, type DocObject, type DocRecord, type DocResponse, type DocSet, type DocTypes, type DocUpdate, type DocValue, type DocWithId, type FPStats, type Falsy, type FileTransactionMeta, type GatewayUrls, type GatewayUrlsParam, type HasCRDT, type HasLogger, type HasSuperThis, type IdxMeta, type IdxMetaMap, Index, type IndexKey, type IndexKeyType, type IndexRow, type IndexRows, type IndexTransactionMeta, type IndexUpdate, type IndexUpdateString, type Joiner, type KeyLiteral, type Ledger, LedgerFactory, type LedgerOpts, LedgerShell, type ListenerFn, type MapFn, type MetaType, type NoUpdateListenerFn, NotFoundError, PACKAGE_VERSION, PARAM, type PARAMS, type PathOps, type PromiseToUInt8, type QueryOpts, type ReadyCloseDestroy, type RefLedger, type Store, type StoreType, type SuperThis, type SuperThisOpts, type SysFileSystem, type TextEndeCoder, type ToUInt8, UInt8ArrayEqual, type UnReg$1 as UnReg, type UnknownDoc, type Unreg, type UpdateListenerFn, type VoidFn, type WriteQueue, index$8 as blockstore, index$8 as bs, coerceIntoUint8, coercePromiseIntoUint8, defaultWriteQueueOpts, ensureLogger, ensureSuperLog, ensureSuperThis, ensureURIDefaults, exceptionWrapper, falsyToUndef, fireproof, getKey, getName, getStore, index$7 as index, inplaceFilter, isDatabase, isFalsy, isLedger, isNotFoundError, keyConfigOpts, makeName, onSuperThis, index as protocols, index as ps, index$2 as rt, index$2 as runtime, setPresetEnv, storeType2DataMetaWal, throwFalsy, toSortedArray, toStoreURIRuntime };
+declare module '@fireproof/core'