/**
 * Registry-backed credential issuance orchestration.
 *
 * KERIpy correspondence:
 * - mirrors the single-sig portions of `keri.vdr.credentialing`
 * - keeps registry/TEL ownership in `Reger` + `Tevery`
 * - keeps credential validation/save ownership in `Verifier`
 *
 * Current boundary:
 * - multisig/counselor and network dissemination escrows are represented by
 *   KERIpy-shaped stores, but only the local single-sig path completes here.
 */
import { Diger, type Kind, NumberPrimitive, Prefixer, Seqner, SerderACDC, SerderKERI, type Versionage } from "../../../cesr/mod.js";
import type { Hab, Habery } from "../app/habbing.js";
import { Verifier, type VerifierDecision } from "../app/verifying.js";
import type { AgentCue } from "../core/cues.js";
import { Deck } from "../core/deck.js";
import type { Reger } from "../db/reger.js";
import { type TelProcessDecision, Tevery } from "./eventing.js";
export interface RegeryOptions {
    reger: Reger;
    tvy?: Tevery;
    vry?: Verifier;
    cues?: Deck<AgentCue>;
}
export interface RegistryOptions {
    name: string;
    hab: Hab;
    reger: Reger;
    tvy: Tevery;
    cues?: Deck<AgentCue>;
    regk?: string;
    noBackers?: boolean;
    estOnly?: boolean;
}
export interface RegistryInceptOptions {
    noBackers?: boolean;
    estOnly?: boolean;
    nonce?: string;
    baks?: string[];
    toad?: number | string;
}
export interface CredentialBuildOptions {
    issuer: string;
    registry: string;
    schema: string;
    data?: Record<string, unknown> | string;
    recipient?: string;
    edges?: Record<string, unknown> | Record<string, unknown>[];
    rules?: Record<string, unknown> | Record<string, unknown>[];
    private?: boolean;
    privateCredentialNonce?: string;
    privateSubjectNonce?: string;
    dt?: string;
    version?: Versionage;
    kind?: Kind;
}
export interface CredentialerOptions {
    reger: Reger;
    vry: Verifier;
    cues?: Deck<AgentCue>;
}
export interface CredentialIssueResult {
    creder: SerderACDC;
    tel: SerderKERI;
    telDecision: TelProcessDecision;
    verifierDecision: VerifierDecision;
}
export interface AnchorSeal {
    prefixer: Prefixer;
    seqner: NumberPrimitive;
    saider: Diger;
}
/** Build one public registry-backed ACDC credential. */
export declare function credential({ issuer, registry, schema, data, recipient, edges, rules, private: privateCredential, privateCredentialNonce, privateSubjectNonce, dt, version, kind, }: CredentialBuildOptions): SerderACDC;
/** Serialize one ACDC plus the KERIpy grant/export seal-source triple. */
export declare function serializeCredential(creder: SerderACDC, prefixer: Prefixer, seqner: NumberPrimitive | Seqner, saider: Diger, gvrsn?: Versionage): Uint8Array;
/** Registry collection owner for one Habery. */
export declare class Regery {
    readonly hby: Habery;
    readonly reger: Reger;
    readonly tvy: Tevery;
    readonly vry: Verifier;
    readonly cues: Deck<AgentCue>;
    readonly registries: Map<string, Registry>;
    constructor(hby: Habery, options: RegeryOptions);
    loadRegistries(): void;
    makeRegistry(name: string, hab: Hab, options?: RegistryInceptOptions): Registry;
    registryByName(name: string): Registry | null;
    processEscrows(): void;
}
/** One credential registry controlled by one issuer habitat. */
export declare class Registry {
    readonly name: string;
    readonly hab: Hab;
    readonly reger: Reger;
    readonly tvy: Tevery;
    readonly cues: Deck<AgentCue>;
    regk: string | null;
    noBackers: boolean;
    estOnly: boolean;
    constructor(options: RegistryOptions);
    incept(options?: RegistryInceptOptions): TelProcessDecision;
    rotate(options?: {
        toad?: number | string;
        cuts?: string[];
        adds?: string[];
    }): TelProcessDecision;
    issue(creder: SerderACDC): {
        serder: SerderKERI;
        decision: TelProcessDecision;
        seal: AnchorSeal;
    };
    revoke(credentialSaid: string): {
        serder: SerderKERI;
        decision: TelProcessDecision;
        seal: AnchorSeal;
    };
    complete(pre: string, sn?: number): boolean;
    private markComplete;
    private requireRegk;
    private currentTever;
}
/** Local registrar facade over the single-sig registry completion path. */
export declare class Registrar {
    readonly rgy: Regery;
    constructor(rgy: Regery);
    incept(registry: Registry, options?: RegistryInceptOptions): TelProcessDecision;
    issue(registry: Registry, creder: SerderACDC): TelProcessDecision;
    revoke(registry: Registry, credentialSaid: string): TelProcessDecision;
    complete(registry: Registry, pre: string, sn?: number): boolean;
    processEscrows(): void;
}
/** Create, validate, issue, and index credentials for one local registry lane. */
export declare class Credentialer {
    readonly hby: Habery;
    readonly reger: Reger;
    readonly vry: Verifier;
    readonly cues: Deck<AgentCue>;
    constructor(hby: Habery, options: CredentialerOptions);
    create(args: {
        registry: Registry;
        schema: string;
        data?: Record<string, unknown> | string;
        recipient?: string;
        edges?: Record<string, unknown> | Record<string, unknown>[];
        rules?: Record<string, unknown> | Record<string, unknown>[];
        private?: boolean;
        privateCredentialNonce?: string;
        privateSubjectNonce?: string;
    }): SerderACDC;
    validate(creder: SerderACDC): boolean;
    issue(registry: Registry, creder: SerderACDC): CredentialIssueResult;
    complete(credentialSaid: string): boolean;
    processCredentialMissingSigEscrow(): void;
}
/** Thin holder wallet over KERIpy-compatible verifier indexes. */
export declare class CredentialWallet {
    readonly reger: Reger;
    constructor(reger: Reger);
    getCredentials(schema?: string): Array<[SerderACDC, Prefixer, NumberPrimitive, Diger]>;
    list({ issued, aid, schema }?: {
        issued?: boolean;
        aid?: string;
        schema?: string;
    }): string[];
    exportCredential(credentialSaid: string): Uint8Array;
}
//# sourceMappingURL=credentialing.d.ts.map