/** KERI event-log databaser built on `LMDBer` composition. */
import { type Operation } from "effection";
import { Cigar, Dater, Diger, NumberPrimitive, Prefixer, Saider, SerderKERI, Siger, Texter } from "../../../cesr/mod.js";
import { Kever } from "../core/kever.js";
import { BlindedImageTuple, BlindedStateQuadrupleTuple, BoundStateSextuple, CacheTypeRecord, EndpointRecord, EscrowedValidatorReceiptQuintuple, EventSealTuple, EventSourceRecord, type EventSourceRecordShape, FirstSeenReplayCouple, HabitatRecord, type HabitatRecordShape, KeyStateRecord, type KeyStateRecordShape, LocationRecord, MsgCacheRecord, ObservedRecord, OobiRecord, ReceiptCouple, SourceSealTriple, TopicsRecord, TxnMsgCacheRecord, TypedDigestSealCouple, TypedMediaQuadrupleTuple, UnverifiedReceiptTriple, ValidatorReceiptQuadruple, VerferCigarCouple, WellKnownAuthN } from "../core/records.js";
import { LMDBerOptions } from "./core/lmdber.js";
import { IoSetKomer, Komer } from "./koming.js";
import { B64OnIoDupSuber, CatCesrIoSetSuber, CatCesrSuber, CesrIoSetSuber, CesrOnSuber, CesrSuber, IoSetSuber, OnIoDupSuber, OnSuber, SchemerSuber, SerderSuber, Suber } from "./subing.js";
/** Options for opening a `Baser` LMDB environment and its named subdb surface. */
export interface BaserOptions extends LMDBerOptions {
    compat?: boolean;
}
/**
 * High-level event-log databaser for KERI application state.
 *
 * Responsibilities:
 * - own the LMDB environment used for KEL/event-adjacent state
 * - bind the KERIpy-style named subdb surface through `Suber`/`Komer`
 * - expose a small set of runtime helpers for local habitat state bootstrap
 *
 * Bound store categories:
 * - event/state backbone (`evts.`, `kels.`, `fels.`, `dtss.`, `states.`)
 * - signatures/receipts and escrow families
 * - reply/endpoint/OOBI and exchange/challenge/contact families
 * - habitat/application metadata and KRAM cache records
 *
 * KERIpy correspondence:
 * - mirrors the named-subdb inventory of `keri.db.basing.Baser`
 *
 * Current `keri-ts` difference:
 * - the full store surface is now bound, but only the local habitat/runtime
 *   subset is actively driven by `Habery`/CLI in this arc
 */
export declare class Baser {
    private lmdber;
    private readonly logger;
    private evtsRaw;
    readonly kevers: Map<string, Kever>;
    readonly prefixes: Set<string>;
    readonly groups: Set<string>;
    evts: SerderSuber<SerderKERI>;
    fels: OnSuber<string>;
    kels: OnIoDupSuber<string>;
    dtss: CesrSuber<Dater>;
    aess: CatCesrSuber<EventSealTuple>;
    sigs: CesrIoSetSuber<Siger>;
    wigs: CesrIoSetSuber<Siger>;
    rcts: CatCesrIoSetSuber<ReceiptCouple>;
    ures: CatCesrIoSetSuber<UnverifiedReceiptTriple>;
    vrcs: CatCesrIoSetSuber<ValidatorReceiptQuadruple>;
    vres: CatCesrIoSetSuber<EscrowedValidatorReceiptQuintuple>;
    pses: OnIoDupSuber<string>;
    pwes: OnIoDupSuber<string>;
    pdes: OnIoDupSuber<string>;
    udes: CatCesrSuber<EventSealTuple>;
    uwes: B64OnIoDupSuber<string[]>;
    ooes: OnIoDupSuber<string>;
    dels: OnIoDupSuber<string>;
    ldes: OnIoDupSuber<string>;
    qnfs: IoSetSuber<string>;
    fons: CesrSuber<NumberPrimitive>;
    migs: CesrSuber<Dater>;
    vers: Suber;
    esrs: Komer<EventSourceRecord>;
    misfits: IoSetSuber<string>;
    delegables: IoSetSuber<string>;
    states: Komer<KeyStateRecord>;
    wits: CesrIoSetSuber<Prefixer>;
    habs: Komer<HabitatRecord>;
    names: Suber;
    sdts: CesrSuber<Dater>;
    ssgs: CesrIoSetSuber<Siger>;
    scgs: CatCesrIoSetSuber<VerferCigarCouple>;
    rpys: SerderSuber<SerderKERI>;
    rpes: CesrIoSetSuber<Diger>;
    eans: CesrSuber<Diger>;
    lans: CesrSuber<Diger>;
    ends: Komer<EndpointRecord>;
    locs: Komer<LocationRecord>;
    obvs: Komer<ObservedRecord>;
    tops: Komer<TopicsRecord>;
    gpse: CatCesrIoSetSuber<EventSealTuple>;
    gdee: CatCesrIoSetSuber<EventSealTuple>;
    gpwe: CatCesrIoSetSuber<EventSealTuple>;
    cgms: CesrSuber<Diger>;
    epse: SerderSuber<SerderKERI>;
    epsd: CesrSuber<Dater>;
    exns: SerderSuber<SerderKERI>;
    erpy: CesrSuber<Saider>;
    esigs: CesrIoSetSuber<Siger>;
    ecigs: CatCesrIoSetSuber<VerferCigarCouple>;
    epath: IoSetSuber<string>;
    essrs: CesrIoSetSuber<Texter>;
    chas: CesrIoSetSuber<Diger>;
    reps: CesrIoSetSuber<Diger>;
    wkas: IoSetKomer<WellKnownAuthN>;
    kdts: CesrSuber<Dater>;
    ksns: Komer<KeyStateRecord>;
    knas: CesrSuber<Diger>;
    wwas: CesrSuber<Diger>;
    oobis: Komer<OobiRecord>;
    eoobi: Komer<OobiRecord>;
    coobi: Komer<OobiRecord>;
    roobi: Komer<OobiRecord>;
    woobi: Komer<OobiRecord>;
    moobi: Komer<OobiRecord>;
    mfa: Komer<OobiRecord>;
    rmfa: Komer<OobiRecord>;
    schema: SchemerSuber;
    cfld: Suber;
    hbys: Suber;
    cons: Suber;
    ccigs: CesrSuber<Cigar>;
    imgs: CatCesrSuber<BlindedImageTuple>;
    ifld: Suber;
    sids: Suber;
    icigs: CesrSuber<Cigar>;
    iimgs: CatCesrSuber<BlindedImageTuple>;
    dpwe: SerderSuber<SerderKERI>;
    dune: SerderSuber<SerderKERI>;
    dpub: SerderSuber<SerderKERI>;
    cdel: CesrOnSuber<Diger>;
    meids: CesrIoSetSuber<Saider>;
    maids: CesrIoSetSuber<Prefixer>;
    ctyp: Komer<CacheTypeRecord>;
    msgc: Komer<MsgCacheRecord>;
    tmsc: Komer<TxnMsgCacheRecord>;
    pmkm: SerderSuber<SerderKERI>;
    pmks: CesrIoSetSuber<Siger>;
    pmsk: CatCesrSuber<EventSealTuple>;
    trqs: CatCesrIoSetSuber<ValidatorReceiptQuadruple>;
    tsgs: CatCesrIoSetSuber<ValidatorReceiptQuadruple>;
    sscs: CatCesrIoSetSuber<EventSealTuple>;
    ssts: CatCesrIoSetSuber<SourceSealTriple>;
    frcs: CatCesrIoSetSuber<FirstSeenReplayCouple>;
    tdcs: CatCesrIoSetSuber<TypedDigestSealCouple>;
    ptds: IoSetSuber<string>;
    bsqs: CatCesrIoSetSuber<BlindedStateQuadrupleTuple>;
    bsss: CatCesrIoSetSuber<BoundStateSextuple>;
    tmqs: CatCesrIoSetSuber<TypedMediaQuadrupleTuple>;
    static readonly TailDirPath = "keri/db";
    static readonly AltTailDirPath = ".tufa/db";
    static readonly CompatAltTailDirPath = ".keri/db";
    static readonly TempPrefix = "keri_db_";
    static readonly MaxNamedDBs = 128;
    constructor(options?: BaserOptions);
    /** Expose the resolved logical database name delegated from the root LMDBer. */
    get name(): string;
    /** Expose the resolved database base prefix delegated from the root LMDBer. */
    get base(): string;
    /** Report whether the root LMDB environment and typed subdb bindings are open. */
    get opened(): boolean;
    /** Report whether this `Baser` uses a temporary backing directory. */
    get temp(): boolean;
    /** Expose the resolved filesystem path of the active backing environment. */
    get path(): string | null;
    /** Expose the raw LMDB environment for low-level tests and debugging only. */
    get env(): import("lmdb").RootDatabase<any, import("lmdb").Key> | null;
    /**
     * Reopen the root LMDB environment and bind the KERIpy-style named subdbs.
     *
     * This keeps the `Baser` layer thin: the constructor owns path/lifecycle
     * defaults, `reopen()` binds the family-specific storage adapters, and
     * higher-layer runtime code interacts through those typed wrappers rather
     * than hand-rolled raw LMDB handles.
     */
    reopen(options?: Partial<BaserOptions>): Operation<boolean>;
    /** Close the underlying LMDB resources. */
    close(clear?: boolean): Operation<boolean>;
    /** Read the root LMDB version marker through the shared lifecycle owner. */
    getVer(): string | null;
    /** Write the root LMDB version marker through the shared lifecycle owner. */
    setVer(val: string): void;
    /** Count raw physical entries in `evts.` for test/debug visibility. */
    cntEvts(): number;
    /** Raw insert helper kept for tests/debug tooling. */
    putEvt(key: Uint8Array, val: Uint8Array): boolean;
    /** Raw upsert helper kept for tests/debug tooling. */
    setEvt(key: Uint8Array, val: Uint8Array): boolean;
    /** Raw fetch helper kept for tests/debug tooling. */
    getEvt(key: Uint8Array): Uint8Array | null;
    /** Raw delete helper kept for tests/debug tooling. */
    delEvt(key: Uint8Array): boolean;
    /** Iterate `evts.` entries with optional byte-prefix filter. */
    getAllEvtsIter(top?: Uint8Array): Generator<[Uint8Array, Uint8Array]>;
    /**
     * Persist one serialized event body in `evts.` under its digest key.
     *
     * Runtime code should prefer this helper over the raw `putEvt()` form so the
     * KERIpy `dgKey(pre, said)` event-key contract stays explicit.
     */
    putEvtSerder(pre: string, said: string, raw: Uint8Array): boolean;
    /** Read one serialized event from `evts.` through the typed serder wrapper. */
    getEvtSerder(pre: string, said: string): SerderKERI | null;
    /** Iterate the latest digest per sequence number for one identifier's KEL. */
    getKelItemIter(pre: string): Generator<[number, string]>;
    /**
     * Iterate every stored KEL event for `pre` from sequence `sn` onward.
     *
     * KERIpy correspondence:
     * - mirrors `Baser.getEvtPreIter(...)`
     *
     * Unlike `getKelItemIter()`, this includes disputed or superseded events
     * still present in `kels.` buckets.
     */
    getEvtPreIter(pre: string, sn?: number): Generator<SerderKERI>;
    /**
     * Return true when `serder` currently satisfies the stored witness threshold.
     *
     * KERIpy correspondence:
     * - mirrors `Baser.fullyWitnessed(...)`
     */
    fullyWitnessed(serder: SerderKERI): boolean;
    /**
     * Find the first fully witnessed event in `pre`'s KEL that carries `seal`.
     *
     * KERIpy correspondence:
     * - mirrors `Baser.fetchAllSealingEventByEventSeal(...)`
     */
    fetchAllSealingEventByEventSeal(pre: string, seal: unknown, sn?: number): SerderKERI | null;
    /**
     * Find the first fully witnessed last-accepted event in `pre`'s KEL that carries `seal`.
     *
     * KERIpy correspondence:
     * - mirrors `Baser.fetchLastSealingEventByEventSeal(...)`
     * - only searches the last accepted event at each sequence number, excluding
     *   superseded/disputed alternatives still retained in `kels.`
     */
    fetchLastSealingEventByEventSeal(pre: string, seal: unknown, sn?: number): SerderKERI | null;
    /** Append one digest to the first-seen event log for a prefix and return the assigned ordinal. */
    appendFel(pre: string, said: string): number;
    /** Read one first-seen digest by `(pre, fn)` from `fels.`. */
    getFel(pre: string, fn: number): string | null;
    /** Resolve the first-seen ordinal for one previously stored event digest. */
    getFelFn(pre: string, said: string): number | null;
    /** Upsert the datetime stamp for one event digest in `dtss.`. */
    putDts(pre: string, said: string, qb64: string): boolean;
    /** Read the stored datetime stamp for one event digest from `dtss.`. */
    getDts(pre: string, said: string): string | null;
    /** Insert one event-source record in `esrs.` if absent. */
    putEsr(pre: string, said: string, record: EventSourceRecordShape): boolean;
    /** Upsert one event-source record in `esrs.`. */
    pinEsr(pre: string, said: string, record: EventSourceRecordShape): boolean;
    /** Read one event-source record from `esrs.`. */
    getEsr(pre: string, said: string): EventSourceRecord | null;
    /** Insert one current key-state record in `states.` if absent. */
    putState(pre: string, record: KeyStateRecordShape): boolean;
    /** Upsert one current key-state record in `states.`. */
    pinState(pre: string, record: KeyStateRecordShape): boolean;
    /** Read one current key-state record from `states.`. */
    getState(pre: string): KeyStateRecord | null;
    /**
     * Rebuild accepted local-hab kevers from durable `habs.` and `states.`.
     *
     * KERIpy correspondence:
     * - mirrors `keri.db.basing.Baser.reload()`
     *
     * Current `keri-ts` difference:
     * - hidden non-hab accepted state such as the signator is still rehydrated
     *   lazily through `getKever()` instead of living in a Python-style
     *   read-through mapping
     */
    reloadKevers(): void;
    /**
     * Return one live `Kever`, rehydrating it from `states.` when needed.
     *
     * This is the TypeScript-native replacement for KERIpy's read-through
     * `db.kevers` dict behavior.
     *
     * `refresh` lets long-lived hosts notice current state committed by sibling
     * CLI processes before answering replay/query requests.
     */
    getKever(pre: string, options?: {
        refresh?: boolean;
    }): Kever | null;
    /** Iterate raw serialized events in KEL order for one identifier prefix. */
    getKelRawIter(pre: string): Generator<Uint8Array>;
    /**
     * Rebuild one CESR event message with its attached foot from DB state.
     *
     * KERIpy correspondence:
     * - mirrors `keri.db.basing.Baser.cloneEvtMsg`
     *
     * This is the durable export/replay seam for locally stored events. The
     * event body comes from `evts.`, while the attached foot is reconstructed
     * from the companion stores that hold controller signatures, witness
     * signatures, source seals, receipts, and first-seen replay metadata.
     */
    cloneEvtMsg(pre: string, fn: number, said: string): Uint8Array;
    /**
     * Replay one identifier's events in first-seen order as full CESR messages.
     *
     * KERIpy correspondence:
     * - mirrors `keri.db.basing.Baser.clonePreIter`
     *
     * Errors rebuilding individual events are skipped so export/replay callers
     * can continue streaming later entries, matching KERIpy's clone behavior.
     */
    clonePreIter(pre: string, fn?: number): Generator<Uint8Array>;
    /**
     * Recursively replay the delegator chain for one delegated `Kever`.
     *
     * KERIpy correspondence:
     * - mirrors `Baser.cloneDelegation(...)`
     */
    cloneDelegation(kever: Kever): Generator<Uint8Array>;
    /** Insert one habitat metadata record in `habs.` if absent. */
    putHab(pre: string, record: HabitatRecordShape): boolean;
    /** Upsert one habitat metadata record in `habs.`. */
    pinHab(pre: string, record: HabitatRecordShape): boolean;
    /** Read one habitat metadata record from `habs.`. */
    getHab(pre: string): HabitatRecord | null;
    /** Iterate persisted habitat metadata records keyed by identifier prefix. */
    getHabItemIter(top?: string): Generator<[string, HabitatRecord]>;
    /** Insert indexed signatures for one event in `sigs.` if absent. */
    putSigs(pre: string, said: string, sigs: readonly (Siger | string)[]): boolean;
    /** Upsert indexed signatures for one event in `sigs.`. */
    pinSigs(pre: string, said: string, sigs: readonly (Siger | string)[]): boolean;
    /** Read indexed signatures for one event from `sigs.` as qb64 text. */
    getSigs(pre: string, said: string): string[];
    /** Insert one namespace/name to prefix mapping in `names.` if absent. */
    putName(ns: string, name: string, pre: string): boolean;
    /** Upsert one namespace/name to prefix mapping in `names.`. */
    pinName(ns: string, name: string, pre: string): boolean;
    /** Read one namespace/name to prefix mapping from `names.`. */
    getName(ns: string, name: string): string | null;
    /** Upsert one habery-scoped string setting in `hbys.`. */
    pinHby(name: string, value: string): boolean;
    /** Read one habery-scoped string setting from `hbys.`. */
    getHby(name: string): string | null;
}
/**
 * Thin Effection-native lifecycle host for one `Baser`.
 *
 * KERIpy correspondence:
 * - mirrors `keri.db.basing.BaserDoer`
 *
 * Current `keri-ts` difference:
 * - exposes explicit generator operations instead of HIO `Doer` callbacks, but
 *   keeps the same ownership rule: reopen on enter, close on exit
 */
export declare class BaserDoer {
    readonly baser: Baser;
    constructor(baser: Baser);
    /** Reopen the bound `Baser` if it is not already opened. */
    enter(options?: Partial<BaserOptions>): Operation<void>;
    /** Close the bound `Baser`, clearing temp stores the same way KERIpy does. */
    exit(): Operation<void>;
    /**
     * Hold the `Baser` open for the surrounding Effection scope.
     *
     * This is the direct replacement for the Python doer staying alive between
     * `enter()` and `exit()` calls.
     */
    run(options?: Partial<BaserOptions>): Operation<never>;
}
/** Constructor-safe async factory for a fully reopened `Baser`. */
export declare function createBaser(options?: BaserOptions): Operation<Baser>;
//# sourceMappingURL=basing.d.ts.map