/**
 * Transaction event log state processing.
 *
 * KERIpy correspondence:
 * - mirrors `keri.vdr.eventing.Tever` and the TEL-facing portions of
 *   `Tevery`
 *
 * `keri-ts` difference:
 * - normal remote-processing outcomes are returned as typed decisions instead
 *   of being represented by Python control-flow exceptions.
 */
import { Diger, Ilks, NumberPrimitive, Prefixer, type SealSource, SerderKERI, Siger } from "../../../cesr/mod.js";
import type { AgentCue } from "../core/cues.js";
import { Deck } from "../core/deck.js";
import { RegStateRecord, VcStateRecord } from "../core/records.js";
import type { Baser } from "../db/basing.js";
import type { Reger } from "../db/reger.js";
type TelIlk = typeof Ilks.vcp | typeof Ilks.vrt | typeof Ilks.iss | typeof Ilks.rev | typeof Ilks.bis | typeof Ilks.brv;
type TelEscrowKind = "outOfOrder" | "anchorless" | "partialWitness";
export type TelProcessDecision = {
    kind: "accept";
    regk: string;
    pre: string;
    said: string;
    ilk: TelIlk;
} | {
    kind: "duplicate";
    regk: string;
    pre: string;
    said: string;
    ilk: TelIlk;
    reason: string;
} | {
    kind: "escrow";
    escrow: TelEscrowKind;
    regk: string;
    pre: string;
    said: string;
    ilk: TelIlk;
    reason: string;
} | {
    kind: "reject";
    regk?: string;
    pre?: string;
    said?: string;
    ilk?: string | null;
    reason: string;
};
export interface TelProcessEventArgs {
    serder: SerderKERI;
    seqner?: SealSource["s"] | NumberPrimitive | null;
    saider?: SealSource["d"] | Diger | null;
    wigers?: readonly Siger[] | null;
    sigers?: readonly Siger[] | null;
    local?: boolean;
}
export interface TeveryOptions {
    reger: Reger;
    db: Baser;
    local?: boolean;
    lax?: boolean;
    cues?: Deck<AgentCue>;
}
export interface TeverOptions extends TeveryOptions {
    rsr?: RegStateRecord | null;
    serder?: SerderKERI | null;
    seqner?: NumberPrimitive | null;
    saider?: Diger | null;
    bigers?: readonly Siger[] | null;
    noBackers?: boolean | null;
    estOnly?: boolean | null;
    regk?: string | null;
}
/**
 * Registry transaction event verifier.
 *
 * `Tever` owns accepted TEL state for one registry. It writes durable TEL
 * artifacts through `Reger`; `Tevery` owns routing, cache insertion, and escrow
 * replay.
 */
export declare class Tever {
    readonly db: Baser;
    readonly reger: Reger;
    readonly local: boolean;
    readonly cues: Deck<AgentCue>;
    version: {
        major: number;
        minor: number;
    };
    pre: string;
    regk: string;
    prefixer: Prefixer;
    sn: number;
    ilk: TelIlk;
    serder: SerderKERI;
    toad: number;
    baks: string[];
    cuts: string[];
    adds: string[];
    noBackers: boolean;
    estOnly: boolean;
    constructor(options: TeverOptions);
    /** Reload one registry state from `Reger.states`. */
    reload(rsr: RegStateRecord): void;
    /** Current registry transaction-state record. */
    state(): RegStateRecord;
    /** Current credential transaction-state record for one credential SAID. */
    vcState(vci: string): VcStateRecord | null;
    /** Return the latest credential TEL ordinal, or `null` when never issued. */
    vcSn(vci: string): number | null;
    update(args: TelProcessEventArgs): TelProcessDecision;
    private incept;
    private config;
    private updateRotation;
    private rotate;
    private issue;
    private revoke;
    private validateToad;
    private valAnchorBigs;
    private verifyAnchor;
    private escrowPWEvent;
    private escrowALEvent;
    private getBackerState;
    private logEvent;
}
/**
 * TEL event router and escrow reprocessor.
 *
 * `Tevery` owns registry-key routing, expected sequence checks, accepted
 * `Tever` cache persistence, and replay of anchorless/out-of-order TEL
 * escrows.
 */
export declare class Tevery {
    static readonly TimeoutTSN = 3600000;
    readonly db: Baser;
    readonly reger: Reger;
    readonly local: boolean;
    readonly lax: boolean;
    readonly cues: Deck<AgentCue>;
    constructor(options: TeveryOptions);
    get tevers(): Map<string, Tever>;
    get registries(): Set<string>;
    /** Rehydrate cached TEL state from KERIpy-compatible registry state records. */
    reloadRegistryStates(): void;
    processEvent(args: TelProcessEventArgs): TelProcessDecision;
    processEscrows(): void;
    processEscrowOutOfOrders(): void;
    processEscrowAnchorless(): void;
    static registryKey(serder: SerderKERI): string;
    private cacheTever;
    private escrowOOEvent;
}
export declare function isAcceptedTelDecision(decision: TelProcessDecision): decision is Extract<TelProcessDecision, {
    kind: "accept";
}>;
export {};
//# sourceMappingURL=eventing.d.ts.map