import { type Database } from "lmdb";
import { Cipher, type Counter, type Decrypter, type Encrypter, type Indexer, Matter, type Serder, SerderKERI, Signer } from "../../../cesr/mod.js";
import { Schemer } from "../core/scheming.js";
import { BinKey, BinVal, LMDBer } from "./core/lmdber.js";
type KeyPart = string | Uint8Array;
type Keys = KeyPart | Iterable<KeyPart>;
type CesrValue = Matter | Indexer | Counter;
type QualifiedCtor<T extends CesrValue> = new (init: {
    qb64b: Uint8Array;
} | {
    qb64: string;
}) => T;
type SerderCtor<T extends Serder> = {
    new (init?: any): T;
    name: string;
};
/**
 * Shared keyspace/value-shape adapter base for KERIpy-style sub-databases.
 *
 * Responsibilities:
 * - open one named LMDB subdb from an owning `LMDBer`
 * - convert tuple-like keyspace paths into separator-delimited LMDB keys
 * - provide KERIpy-style branch helpers shared across all `Suber` families
 */
export declare class SuberBase<T = string> {
    static readonly Sep = ".";
    protected readonly db: LMDBer;
    readonly sdb: Database<BinVal, BinKey>;
    readonly sep: string;
    readonly verify: boolean;
    constructor(db: LMDBer, { subkey, dupsort, sep, verify, }: {
        subkey: string;
        dupsort?: boolean;
        sep?: string;
        verify?: boolean;
    });
    /** Convert one logical key path into one physical LMDB key. */
    protected _tokey(keys: Keys, topive?: boolean): Uint8Array;
    /** Convert one physical LMDB key back into its logical key path. */
    protected _tokeys(key: Uint8Array): string[];
    /** Serialize one logical value into the raw LMDB byte representation. */
    protected _ser(val: T): Uint8Array;
    /** Deserialize one raw LMDB byte value into the logical wrapper type. */
    protected _des(val: Uint8Array | null): T | null;
    /** Remove all stored entries under one logical branch prefix. */
    trim(keys?: Keys, { topive }?: {
        topive?: boolean;
    }): boolean;
    /** KERIpy-style alias for `trim()`. */
    remTop(keys?: Keys, { topive }?: {
        topive?: boolean;
    }): boolean;
    /** Count all physical entries under one logical branch prefix. */
    cntTop(keys?: Keys, { topive }?: {
        topive?: boolean;
    }): number;
    /** Count every stored entry in this subdb family. */
    cntAll(): number;
    /** Alias matching KERIpy's mixed wrapper counting vocabulary. */
    cnt(): number;
    /** Iterate logical branch items for one key prefix. */
    getTopItemIter(keys?: Keys, { topive }?: {
        topive?: boolean;
    }): Generator<[string[], T]>;
    /**
     * Iterate the full stored item view for this family.
     *
     * Families that hide suffixes or proems override this to expose those
     * details when tests or debuggers need the physical-storage view.
     */
    getFullItemIter(keys?: Keys, { topive }?: {
        topive?: boolean;
    }): Generator<[string[], T]>;
}
/**
 * Single-value non-duplicate subdb family (`Suber`).
 */
export declare class Suber<T = string> extends SuberBase<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Insert one single-value record if the effective key is absent. */
    put(keys: Keys, val: T): boolean;
    /** Upsert one single-value record at its effective key. */
    pin(keys: Keys, val: T): boolean;
    /** Read one single-value record from its effective key. */
    get(keys: Keys): T | null;
    /** Remove one single-value record by its effective key. */
    rem(keys: Keys): boolean;
    /** Compatibility alias; `getTopItemIter()` is the parity branch iterator. */
    getItemIter(keys?: Keys, { topive }?: {
        topive?: boolean;
    }): Generator<[string[], T]>;
}
/**
 * Exposed-ordinal key family (`On*`).
 *
 * Maintainer note:
 * - KERIpy normalized this family around `getTopItemIter` / `getAllItemIter` /
 *   `getAllIter`
 * - the older `getOn*` names remain here as compatibility wrappers so current
 *   `keri-ts` call sites do not need to migrate yet
 */
export declare class OnSuberBase<T = string> extends SuberBase<T> {
    /** Insert one value at an exposed ordinal bucket if that exact bucket is empty. */
    putOn(keys: Keys, on?: number, val?: T | null): boolean;
    /** Upsert one value at an exposed ordinal bucket. */
    pinOn(keys: Keys, on?: number, val?: T | null): boolean;
    /** Append one value at the next exposed ordinal bucket for a logical key path. */
    appendOn(keys: Keys, val: T): number;
    /** Read the full `(keys, on, value)` triple for one exact exposed ordinal bucket. */
    getOnItem(keys: Keys, on?: number): [string[], number, T] | null;
    /** Read the value stored at one exact exposed ordinal bucket. */
    getOn(keys: Keys, on?: number): T | null;
    /** Remove one exact exposed ordinal bucket. */
    remOn(keys: Keys, on?: number): boolean;
    /** Remove all ordinal buckets from `on` onward under one logical branch. */
    remOnAll(keys?: Keys, on?: number): boolean;
    /** Count ordinal buckets from one starting ordinal under a logical key path. */
    cntOn(keys?: Keys, on?: number): number;
    /** Count ordinal buckets from one starting ordinal across a branch or whole db. */
    cntOnAll(keys?: Keys, on?: number): number;
    getTopItemIter(keys?: Keys): Generator<[string[], number, T]>;
    getTopItemIter(keys?: Keys, _options?: {
        topive?: boolean;
    }): Generator<[string[], T]>;
    /** Compatibility alias for the normalized ordinal-branch iterator. */
    getOnTopItemIter(keys?: Keys): Generator<[string[], number, T]>;
    /** Older alias retained for parity with pre-normalization ordinal scans. */
    getOnItemIter(keys?: Keys): Generator<[string[], number, T]>;
    /** Iterate all ordinal buckets from `on` onward, preserving the exposed ordinal. */
    getAllItemIter(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Compatibility alias for `getAllItemIter()`. */
    getOnAllItemIter(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Older alias for full ordinal scans across a branch. */
    getOnItemIterAll(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Iterate only values across ordinal buckets from `on` onward. */
    getAllIter(keys?: Keys, on?: number): Generator<T>;
    /** Compatibility alias for `getAllIter()`. */
    getOnAllIter(keys?: Keys, on?: number): Generator<T>;
    /** Older alias for the normalized value-only ordinal scan. */
    getOnIterAll(keys?: Keys, on?: number): Generator<T>;
}
/** Concrete exposed-ordinal single-value family. */
export declare class OnSuber<T = string> extends OnSuberBase<T> {
}
/**
 * Raw-byte single-value family.
 *
 * KERIpy's plain `Suber` stores byte payloads directly when callers provide
 * bytes. The default TypeScript `Suber<Uint8Array>` would stringify those
 * bytes, so raw message bodies must use this adapter instead.
 */
export declare class BytesSuber extends Suber<Uint8Array> {
    protected _ser(val: Uint8Array): Uint8Array;
    protected _des(val: Uint8Array | null): Uint8Array | null;
}
/**
 * Base64 tuple value family (`B64*`).
 */
export declare class B64SuberBase<T extends string[] = string[]> extends Suber<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Join one Base64-url tuple into its stored byte representation. */
    protected _toval(vals: string | Uint8Array | Iterable<string | Uint8Array>): Uint8Array;
    /** Split one stored Base64-url tuple payload back into logical string parts. */
    protected _tovals(val: Uint8Array): T;
    /** Serialize one Base64-url tuple using the configured non-Base64 separator. */
    protected _ser(val: T): Uint8Array;
    /** Deserialize one stored Base64-url tuple payload into logical tuple parts. */
    protected _des(val: Uint8Array | null): T | null;
}
/** Concrete Base64 tuple-value family. */
export declare class B64Suber<T extends string[] = string[]> extends B64SuberBase<T> {
}
/**
 * Qualified CESR primitive family (`Cesr*`).
 */
export declare class CesrSuberBase<T extends CesrValue = CesrValue> extends Suber<T> {
    protected readonly ctor: QualifiedCtor<T>;
    protected readonly strict: boolean;
    constructor(db: LMDBer, { subkey, sep, verify, ctor, strict, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
        ctor: QualifiedCtor<T>;
        strict?: boolean;
    });
    protected _ser(val: T): Uint8Array;
    protected _des(val: Uint8Array | null): T | null;
}
/** Concrete qualified-CESR single-value family. */
export declare class CesrSuber<T extends CesrValue = CesrValue> extends CesrSuberBase<T> {
}
/**
 * Qualified CESR primitive family with an exposed ordinal in the keyspace.
 *
 * Storage model:
 * - exposed ordinal in the physical key (`On*`)
 * - one qualified CESR primitive per logical item
 */
export declare class CesrOnSuber<T extends CesrValue = CesrValue> extends OnSuberBase<T> {
    protected readonly ctor: QualifiedCtor<T>;
    protected readonly strict: boolean;
    constructor(db: LMDBer, { subkey, sep, verify, ctor, strict, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
        ctor: QualifiedCtor<T>;
        strict?: boolean;
    });
    protected _ser(val: T): Uint8Array;
    protected _des(val: Uint8Array | null): T | null;
}
/**
 * Concatenated qualified CESR tuple family (`CatCesr*`).
 */
export declare class CatCesrSuberBase<T extends readonly CesrValue[] = readonly CesrValue[]> extends Suber<T> {
    protected readonly ctors: readonly QualifiedCtor<CesrValue>[];
    protected readonly strict: boolean;
    constructor(db: LMDBer, { subkey, sep, verify, ctor, strict, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
        ctor: QualifiedCtor<CesrValue> | readonly QualifiedCtor<CesrValue>[];
        strict?: boolean;
    });
    protected _ser(val: T): Uint8Array;
    protected _des(val: Uint8Array | null): T | null;
}
/** Concrete concatenated-CESR tuple family for one logical item per key. */
export declare class CatCesrSuber<T extends readonly CesrValue[] = readonly CesrValue[]> extends CatCesrSuberBase<T> {
}
/**
 * Insertion-ordered synthetic set family (`IoSet*`).
 */
export declare class IoSetSuber<T = string> extends SuberBase<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Insert a logical insertion-ordered set for one effective key if absent. */
    put(keys: Keys, vals?: T | Iterable<T> | null): boolean;
    /** Upsert a logical insertion-ordered set for one effective key. */
    pin(keys: Keys, vals?: T | Iterable<T> | null): boolean;
    /** Append one logical member to the insertion-ordered set for an effective key. */
    add(keys: Keys, val?: T | null): boolean;
    /** Materialize the logical `(keys, value)` view for one insertion-ordered set bucket. */
    getItem(keys: Keys, { ion }?: {
        ion?: number;
    }): [string[], T][];
    /** Read all logical members for one effective key, hiding synthetic suffixes. */
    get(keys: Keys, { ion }?: {
        ion?: number;
    }): T[];
    /** Iterate logical `(keys, value)` members for one insertion-ordered set bucket. */
    getItemIter(keys: Keys, { ion }?: {
        ion?: number;
    }): Generator<[string[], T]>;
    /** Iterate only logical values for one insertion-ordered set bucket. */
    getIter(keys: Keys, { ion }?: {
        ion?: number;
    }): Generator<T>;
    /** Read the last logical member for one effective key. */
    getLastItem(keys: Keys): [string[], T] | null;
    /** Read only the value component of `getLastItem()`. */
    getLast(keys: Keys): T | null;
    /** Remove one member, or all members when `val` is `null`, from one effective key. */
    rem(keys: Keys, val?: T | null): boolean;
    /** Count members for one effective key, or the whole subdb when the key is empty. */
    cnt(keys?: Keys, { ion }?: {
        ion?: number;
    }): number;
    getTopItemIter(keys?: Keys, { topive }?: {
        topive?: boolean;
    }): Generator<[string[], T]>;
    /** Iterate the last logical value from each effective key in a branch. */
    getLastIter(keys?: Keys): Generator<T>;
    /** Iterate the last logical member for each effective key in a branch. */
    getLastItemIter(keys?: Keys): Generator<[string[], T]>;
    /** Iterate the physical-storage view, including synthetic insertion suffixes. */
    getFullItemIter(keys?: Keys, { topive }?: {
        topive?: boolean;
    }): Generator<[string[], T]>;
}
/**
 * Base64 tuple family over synthetic insertion-ordered sets.
 *
 * Storage model:
 * - synthetic keyspace virtualization (`IoSet*`)
 * - Base64-only tuple-like text payloads
 */
export declare class B64IoSetSuber<T extends string[] = string[]> extends IoSetSuber<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Serialize one Base64-url tuple duplicate member with the configured separator. */
    protected _ser(val: T): Uint8Array;
    /** Deserialize one stored Base64-url duplicate member into logical tuple parts. */
    protected _des(val: Uint8Array | null): T | null;
}
/**
 * Qualified CESR primitive family over synthetic insertion-ordered sets.
 *
 * Storage model:
 * - synthetic keyspace virtualization (`IoSet*`)
 * - one qualified CESR primitive per logical member
 */
export declare class CesrIoSetSuber<T extends CesrValue = CesrValue> extends IoSetSuber<T> {
    protected readonly ctor: QualifiedCtor<T>;
    protected readonly strict: boolean;
    constructor(db: LMDBer, { subkey, sep, verify, ctor, strict, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
        ctor: QualifiedCtor<T>;
        strict?: boolean;
    });
    protected _ser(val: T): Uint8Array;
    protected _des(val: Uint8Array | null): T | null;
}
/**
 * Concatenated CESR tuple family over synthetic insertion-ordered sets.
 *
 * Storage model:
 * - synthetic keyspace virtualization (`IoSet*`)
 * - fixed-order tuples encoded as concatenated qb64 payloads
 */
export declare class CatCesrIoSetSuber<T extends readonly CesrValue[] = readonly CesrValue[]> extends IoSetSuber<T> {
    protected readonly ctors: readonly QualifiedCtor<CesrValue>[];
    protected readonly strict: boolean;
    constructor(db: LMDBer, { subkey, sep, verify, ctor, strict, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
        ctor: QualifiedCtor<CesrValue> | readonly QualifiedCtor<CesrValue>[];
        strict?: boolean;
    });
    /**
     * Serialize one fixed-order CESR tuple into concatenated qb64 bytes.
     *
     * In strict mode, both tuple length and per-slot primitive class must match
     * the configured constructor sequence.
     */
    protected _ser(val: T): Uint8Array;
    /** Hydrate one concatenated CESR tuple from stored qb64 bytes. */
    protected _des(val: Uint8Array | null): T | null;
}
/**
 * Signer storage family keyed by verifier qb64.
 *
 * Maintainer model:
 * - stored value bytes are always the qualified signer seed payload
 * - the final keyspace segment is the authoritative verifier qb64
 * - signer hydration must therefore recover transferability from that verifier
 *   so `Signer.verfer` and `Signer.transferable` survive round-trips
 */
export declare class SignerSuber extends CesrSuberBase<Signer> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Read one signer without local decryption support. */
    get(keys: Keys, _decrypter?: Decrypter): Signer | null;
    /** Iterate signer items while preserving `Signer` hydration semantics. */
    getTopItemIter(keys?: Keys, _decrypterOrOptions?: Decrypter | {
        topive?: boolean;
    }, maybeOptions?: {
        topive?: boolean;
    }): Generator<[string[], Signer]>;
}
/**
 * Signer family that preserves KERIpy's encrypted-signer API surface.
 *
 * Storage model:
 * - single-value CESR family over signer payloads
 * - hydrates stored values as `Signer` instances on read
 *
 * KERIpy correspondence:
 * - mirrors the role of `CryptSignerSuber` for stores like keeper `pris.`
 *
 * Current `keri-ts` difference:
 * - encrypted signer payloads are now handled directly by CESR
 *   `Encrypter`/`Decrypter` primitives instead of a keeper-local crypto shim
 *
 * Maintainer model:
 * - callers still interact in terms of logical signer seeds
 * - this subdb decides whether those logical seeds are stored directly or as
 *   ciphertext based on whether an encrypter/decrypter is supplied
 * - `pris.` therefore stays one logical "public key -> signer seed" map even
 *   though the at-rest bytes change under Gate D
 */
export declare class CryptSignerSuber extends SignerSuber {
    /**
     * Store one signer/cipher payload.
     *
     * When an encrypter is provided, the stored payload is a CESR `Cipher`
     * containing the sealed-box ciphertext of the signer's qb64 seed.
     *
     * Why encrypt the qualified seed text instead of raw bytes:
     * - the decrypt path can reconstruct the original CESR `Signer` without extra
     *   side-channel metadata
     * - the encrypted payload remains aligned with KERIpy's qualified-material
     *   round-trip model
     */
    put(keys: Keys, val: Signer | Cipher | string | Uint8Array, encrypter?: Encrypter): boolean;
    /**
     * Upsert one signer/cipher payload with optional sealed-box encryption.
     *
     * `put()` and `pin()` intentionally share the same encryption semantics so
     * callers do not need separate "encrypted update" code paths.
     */
    pin(keys: Keys, val: Signer | Cipher | string | Uint8Array, encrypter?: Encrypter): boolean;
    /**
     * Read one signer, decrypting the stored ciphertext when a decrypter exists.
     *
     * Failure interpretation:
     * - `null` still means "no record at this key"
     * - decrypt failure means "record exists but current auth material is wrong"
     */
    get(keys: Keys, decrypter?: Decrypter): Signer | null;
    /**
     * Iterate signer items, decrypting stored ciphertext when requested.
     *
     * Maintainer note:
     * AEID re-encryption walks this iterator so it can migrate the whole `pris.`
     * surface without learning any keeper-specific key semantics here.
     */
    getTopItemIter(keys?: Keys, decrypterOrOptions?: Decrypter | {
        topive?: boolean;
    }, maybeOptions?: {
        topive?: boolean;
    }): Generator<[string[], Signer]>;
}
/**
 * Serder/Schemer families.
 */
export declare class SerderSuberBase<T extends Serder = SerderKERI> extends Suber<T> {
    protected readonly ctor: SerderCtor<T>;
    constructor(db: LMDBer, { subkey, sep, verify, ctor, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
        ctor?: SerderCtor<T>;
    });
    protected _ser(val: T): Uint8Array;
    protected _des(val: Uint8Array | null): T | null;
}
/** Concrete single-value serder family. */
export declare class SerderSuber<T extends Serder = SerderKERI> extends SerderSuberBase<T> {
}
/** Raw JSON schema SAD family keyed by schema SAID. */
export declare class SchemerSuber extends Suber<Schemer> {
    protected _ser(val: Schemer): Uint8Array;
    protected _des(val: Uint8Array | null): Schemer | null;
}
/**
 * Serder family over synthetic insertion-ordered sets.
 *
 * Storage model:
 * - synthetic keyspace virtualization (`IoSet*`)
 * - typed serder hydration through `smell()` + `parseSerder()`
 */
export declare class SerderIoSetSuber<T extends Serder = SerderKERI> extends IoSetSuber<T> {
    protected readonly ctor: SerderCtor<T>;
    constructor(db: LMDBer, { subkey, sep, verify, ctor, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
        ctor?: SerderCtor<T>;
    });
    /** Serialize one serder body as its raw bytes. */
    protected _ser(val: T): Uint8Array;
    /** Hydrate one stored raw body through the shared serder parser. */
    protected _des(val: Uint8Array | null): T | null;
}
/** Concrete schemer-style family built on the single-value serder adapter. */
/**
 * Native dupsort duplicate families (`Dup*` / `IoDup*`).
 */
export declare class DupSuber<T = string> extends SuberBase<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Insert all duplicate values at one key if none of those values already exist. */
    put(keys: Keys, vals: T | Iterable<T>): boolean;
    /** Replace the entire duplicate set at one key. */
    pin(keys: Keys, vals: T | Iterable<T>): boolean;
    /** Add one duplicate value if it is not already present at the key. */
    add(keys: Keys, val: T): boolean;
    /** Read all duplicate values stored at one effective key. */
    get(keys: Keys): T[];
    /** Read the lexicographically last duplicate value for one effective key. */
    getLast(keys: Keys): T | null;
    /** Iterate duplicate values at one effective key in LMDB duplicate order. */
    getIter(keys: Keys): Generator<T>;
    /** Count duplicate values at one key, or the whole subdb when the key is empty. */
    cnt(keys?: Keys): number;
    /** Remove one duplicate value, or the whole duplicate set when `val` is `null`. */
    rem(keys: Keys, val?: T | null): boolean;
}
/** Qualified CESR primitive family over native LMDB dupsort duplicates. */
export declare class CesrDupSuber<T extends CesrValue = CesrValue> extends DupSuber<T> {
    protected readonly ctor: QualifiedCtor<T>;
    protected readonly strict: boolean;
    constructor(db: LMDBer, { subkey, sep, verify, ctor, strict, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
        ctor: QualifiedCtor<T>;
        strict?: boolean;
    });
    protected _ser(val: T): Uint8Array;
    protected _des(val: Uint8Array | null): T | null;
}
/** Concatenated CESR tuple family over native LMDB dupsort duplicates. */
export declare class CatCesrDupSuber<T extends readonly CesrValue[] = readonly CesrValue[]> extends DupSuber<T> {
    protected readonly ctors: readonly QualifiedCtor<CesrValue>[];
    protected readonly strict: boolean;
    constructor(db: LMDBer, { subkey, sep, verify, ctor, strict, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
        ctor: QualifiedCtor<CesrValue> | readonly QualifiedCtor<CesrValue>[];
        strict?: boolean;
    });
    protected _ser(val: T): Uint8Array;
    protected _des(val: Uint8Array | null): T | null;
}
/**
 * Insertion-ordered duplicate family using native dupsort plus a hidden value proem.
 *
 * Storage model:
 * - native LMDB duplicates (`dupsort=true`)
 * - hidden insertion-order proem in stored duplicate values
 */
export declare class IoDupSuber<T = string> extends DupSuber<T> {
    /** Insert insertion-ordered duplicate values if their logical members are absent. */
    put(keys: Keys, vals: T | Iterable<T>): boolean;
    /** Replace the entire insertion-ordered duplicate set for one effective key. */
    pin(keys: Keys, vals: T | Iterable<T>): boolean;
    /** Add one logical member if it is not already present in the insertion-ordered set. */
    add(keys: Keys, val: T): boolean;
    /** Read all logical members for one insertion-ordered duplicate set. */
    get(keys: Keys): T[];
    /** Iterate logical members for one insertion-ordered duplicate set. */
    getIter(keys: Keys): Generator<T>;
    /** Read the last inserted logical member for one insertion-ordered duplicate set. */
    getLast(keys: Keys): T | null;
    /** Remove one logical member, or the whole duplicate set when `val` is `null`. */
    rem(keys: Keys, val?: T | null): boolean;
    /** Count insertion-ordered duplicate members at one key or across the whole subdb. */
    cnt(keys?: Keys): number;
    /** Iterate logical branch items while stripping the hidden insertion-order proem. */
    getTopItemIter(keys?: Keys, { topive }?: {
        topive?: boolean;
    }): Generator<[string[], T]>;
}
/** Base64 tuple family over insertion-ordered native duplicates. */
export declare class B64IoDupSuber<T extends string[] = string[]> extends IoDupSuber<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Serialize one Base64-url tuple member for an exposed-ordinal insertion-ordered set. */
    protected _ser(val: T): Uint8Array;
    /** Deserialize one stored Base64-url ordinal-set member into logical tuple parts. */
    protected _des(val: Uint8Array | null): T | null;
}
/**
 * Exposed-ordinal plus insertion-ordered duplicate family.
 *
 * Storage model:
 * - exposed ordinal in the physical key (`On*`)
 * - native dupsort duplicates carrying a hidden insertion-order proem
 *
 * Maintainer note:
 * - KERIpy now prefers normalized names such as `put`, `getTopItemIter`,
 *   `getAllItemIter`, and `getAllIter`
 * - the older `*On*` names stay available here until upper layers migrate
 */
export declare class OnIoDupSuber<T = string> extends SuberBase<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Insert all logical duplicate members into one exact exposed ordinal bucket if absent. */
    put(keys: Keys, on?: number, vals?: T | Iterable<T> | null): boolean;
    /** Compatibility alias retained while higher layers still call the older name. */
    putOn(keys: Keys, on?: number, vals?: T | Iterable<T> | null): boolean;
    /** Replace the entire logical duplicate set at one exact exposed ordinal bucket. */
    pinOn(keys: Keys, on?: number, vals?: T | Iterable<T> | null): boolean;
    /** Add one logical duplicate member to one exact exposed ordinal bucket if absent. */
    addOn(keys: Keys, on: number | undefined, val: T): boolean;
    /** Normalized alias for `addOn()` matching KERIpy ordinal-suber call sites. */
    add(keys: Keys, on: number | undefined, val: T): boolean;
    /** Append one value at the next exposed ordinal bucket. */
    appendOn(keys: Keys, val: T): number;
    /** Read all logical duplicate members for one exact exposed ordinal bucket. */
    getOn(keys: Keys, on?: number): T[];
    /** Iterate logical duplicate members for one exact exposed ordinal bucket. */
    getOnIter(keys: Keys, on?: number): Generator<T>;
    /** Read the last inserted logical duplicate member for one exposed ordinal bucket. */
    getOnLast(keys: Keys, on?: number): T | null;
    /** Normalized alias for `getOnLast()` matching KERIpy ordinal-suber call sites. */
    getLast(keys: Keys, on?: number): T | null;
    /** Remove one logical member, or the whole exposed-ordinal duplicate bucket. */
    remOn(keys: Keys, on?: number, val?: T | null): boolean;
    /** Count logical duplicate members for one exposed ordinal bucket or branch. */
    cntOn(keys?: Keys, on?: number): number;
    getTopItemIter(keys?: Keys): Generator<[string[], number, T]>;
    getTopItemIter(keys?: Keys, _options?: {
        topive?: boolean;
    }): Generator<[string[], T]>;
    /** Compatibility alias for the normalized top-branch ordinal iterator. */
    getOnTopItemIter(keys?: Keys): Generator<[string[], number, T]>;
    /** Iterate logical items across ordinal buckets in forward order. */
    getAllItemIter(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    getOnItemIterAll(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Iterate only logical values across ordinal buckets from `on` onward. */
    getAllIter(keys?: Keys, on?: number): Generator<T>;
    /** Compatibility alias for `getAllIter()`. */
    getOnIterAll(keys?: Keys, on?: number): Generator<T>;
    /** Iterate the last logical duplicate value from each ordinal bucket. */
    getOnLastIter(keys?: Keys, on?: number): Generator<T>;
    /** Iterate the last logical item for each ordinal bucket. */
    getOnLastItemIter(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Iterate logical duplicate items in reverse exposed-ordinal order. */
    getOnItemBackIter(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Iterate only logical values in reverse exposed-ordinal order. */
    getOnBackIter(keys?: Keys, on?: number): Generator<T>;
}
/** Base64 tuple family over exposed-ordinal insertion-ordered duplicates. */
export declare class B64OnIoDupSuber<T extends string[] = string[]> extends OnIoDupSuber<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Serialize one Base64-url tuple member for an exposed-ordinal duplicate bucket. */
    protected _ser(val: T): Uint8Array;
    /** Deserialize one stored Base64-url ordinal-duplicate member into logical tuple parts. */
    protected _des(val: Uint8Array | null): T | null;
}
/**
 * Exposed-ordinal insertion-ordered synthetic sets (`OnIoSet*`).
 *
 * Maintainer note:
 * - KERIpy normalized this family onto the same public verb set used by the
 *   simpler Suber families, with `on` remaining an explicit parameter
 * - the older `*On*` names remain here as compatibility wrappers for existing
 *   `keri-ts` DB call sites
 */
export declare class OnIoSetSuber<T = string> extends SuberBase<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    /** Insert an exposed-ordinal insertion-ordered set bucket if absent. */
    putOn(keys: Keys, on?: number, vals?: T | Iterable<T> | null): boolean;
    /** Replace the insertion-ordered set members for one exact exposed ordinal bucket. */
    pinOn(keys: Keys, on?: number, vals?: T | Iterable<T> | null): boolean;
    /** Add one logical set member to one exact exposed ordinal bucket if absent. */
    addOn(keys: Keys, on: number | undefined, val: T): boolean;
    /** Append a new exposed ordinal bucket populated with one or more logical set members. */
    appendOn(keys: Keys, vals?: T | Iterable<T> | null): number;
    /** Normalized alias for `putOn()` matching later KERIpy `OnIoSetSuber`. */
    put(keys: Keys, on?: number, vals?: T | Iterable<T> | null): boolean;
    /** Normalized alias for `pinOn()`. */
    pin(keys: Keys, on?: number, vals?: T | Iterable<T> | null): boolean;
    /** Normalized alias for `addOn()`. */
    add(keys: Keys, on: number | undefined, val: T): boolean;
    /** Normalized alias for `appendOn()`. */
    append(keys: Keys, vals?: T | Iterable<T> | null): number;
    /** Materialize the logical `(keys, on, value)` view for one ordinal-set bucket. */
    getItem(keys: Keys, on?: number, ion?: number): [string[], number, T][];
    /** Read all logical members from one exposed-ordinal insertion-ordered set bucket. */
    get(keys: Keys, on?: number, ion?: number): T[];
    /** Iterate logical `(keys, on, value)` triples for one ordinal-set bucket. */
    getItemIter(keys: Keys, on?: number, ion?: number): Generator<[string[], number, T]>;
    /** Iterate only logical values from one ordinal-set bucket. */
    getIter(keys: Keys, on?: number, ion?: number): Generator<T>;
    /** Read the last logical member from one exact exposed ordinal-set bucket. */
    getLastItem(keys: Keys, on?: number): [string[], number, T] | null;
    /** Read only the value component of `getLastItem()`. */
    getLast(keys: Keys, on?: number): T | null;
    /** Remove one logical member from an ordinal-set bucket, or the whole bucket when `val` is `null`. */
    rem(keys: Keys, on?: number, val?: T | null): boolean;
    /** Remove all ordinal-set buckets from `on` onward under a branch. */
    remAll(keys?: Keys, on?: number): boolean;
    cnt(): number;
    cnt(keys: Keys, on?: number, ion?: number): number;
    cntAll(): number;
    cntAll(keys?: Keys, on?: number): number;
    getTopItemIter(keys?: Keys): Generator<[string[], number, T]>;
    getTopItemIter(keys?: Keys, _options?: {
        topive?: boolean;
    }): Generator<[string[], T]>;
    /** Iterate logical members across ordinal buckets from `on` onward. */
    getAllItemIter(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Iterate only logical values across ordinal-set buckets from `on` onward. */
    getAllIter(keys?: Keys, on?: number): Generator<T>;
    /** Iterate the last logical member from each ordinal-set bucket. */
    getAllLastItemIter(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Iterate only the last logical values from each ordinal-set bucket. */
    getAllLastIter(keys?: Keys, on?: number): Generator<T>;
    /** Iterate logical members in reverse exposed-ordinal order across a branch. */
    getAllItemBackIter(keys?: Keys, on?: number | null): Generator<[string[], number, T]>;
    /** Iterate only logical values in reverse exposed-ordinal order. */
    getAllBackIter(keys?: Keys, on?: number | null): Generator<T>;
    /** Iterate the last logical member from each ordinal bucket in reverse order. */
    getAllLastItemBackIter(keys?: Keys, on?: number | null): Generator<[string[], number, T]>;
    /** Iterate only the last logical values from each ordinal bucket in reverse order. */
    getAllLastBackIter(keys?: Keys, on?: number | null): Generator<T>;
    /** Legacy alias for `getItem()`. */
    getOnItem(keys: Keys, on?: number): [string[], number, T][];
    /** Legacy alias for `get()`. */
    getOn(keys: Keys, on?: number): T[];
    /** Legacy alias for `getItemIter()`. */
    getOnItemIter(keys: Keys, on?: number): Generator<[string[], number, T]>;
    /** Legacy alias for `getIter()`. */
    getOnIter(keys: Keys, on?: number): Generator<T>;
    /** Legacy alias for `getLastItem()`. */
    getOnLastItem(keys: Keys, on?: number): [string[], number, T] | null;
    /** Legacy alias for `getLast()`. */
    getOnLast(keys: Keys, on?: number): T | null;
    /** Legacy removal surface that still mirrors current upstream call sites. */
    remOn(keys: Keys, on?: number, val?: T | null): boolean;
    /** Legacy alias for `cnt()`. */
    cntOn(keys: Keys, on?: number): number;
    /** Legacy alias for `cntAll()`. */
    cntOnAll(keys?: Keys, on?: number): number;
    /** Legacy alias for `getTopItemIter()`. */
    getOnTopItemIter(keys?: Keys): Generator<[string[], number, T]>;
    /** Legacy alias for `getAllItemIter()`. */
    getOnAllItemIter(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Legacy alias for `getAllLastItemIter()`. */
    getOnLastItemIter(keys?: Keys, on?: number): Generator<[string[], number, T]>;
    /** Legacy alias for `getAllItemBackIter()`. */
    getOnItemBackIter(keys?: Keys, on?: number | null): Generator<[string[], number, T]>;
    /** Legacy alias for `getAllBackIter()`. */
    getOnBackIter(keys?: Keys, on?: number | null): Generator<T>;
}
/** Base64 tuple family over exposed-ordinal synthetic insertion-ordered sets. */
export declare class B64OnIoSetSuber<T extends string[] = string[]> extends OnIoSetSuber<T> {
    constructor(db: LMDBer, { subkey, sep, verify, }: {
        subkey: string;
        sep?: string;
        verify?: boolean;
    });
    protected _ser(val: T): Uint8Array;
    protected _des(val: Uint8Array | null): T | null;
}
export {};
//# sourceMappingURL=subing.d.ts.map