import { Diger } from "./diger.js";
import { Labeler } from "./labeler.js";
import type { Matter, MatterInit } from "./matter.js";
import { Noncer } from "./noncer.js";
import { NumberPrimitive } from "./number.js";
import { Prefixer } from "./prefixer.js";
import { Texter } from "./texter.js";
import { Verser } from "./verser.js";
type Qb64b = Uint8Array;
/**
 * Fixed-field CESR primitive admitted by KERIpy `structing.py` cast tables.
 *
 * Maintainer model:
 * - this is the only public primitive taxonomy the module needs
 * - the named struct values themselves stay plain frozen records
 */
export type StructingPrimitive = Diger | Labeler | Noncer | NumberPrimitive | Prefixer | Texter | Verser;
/**
 * Field-cast metadata ported from KERIpy `Castage`.
 *
 * `ipn` records which primitive property should be exposed in crew/object
 * form. When `ipn` is `null`, the field serializes through canonical `qb64`.
 */
export type Castage = Readonly<{
    kls: new (init: Matter | MatterInit) => StructingPrimitive;
    ipn: string | null;
}>;
/**
 * Build one immutable cast entry.
 *
 * KERIpy substance:
 * - mirrors `Castage(kls=..., ipn=...)`
 *
 * `ipn` is the string projection name used in crew/SAD form. For example:
 * - `NumberPrimitive` uses `numh`
 * - `Noncer` uses `nonce`
 * - `Labeler` / `Texter` use `text`
 * - `null` falls back to canonical `qb64`
 */
export declare function castage(kls: new (init: Matter | MatterInit) => StructingPrimitive, ipn?: string | null): Castage;
export type StructingCoden = "DigestSealSingles" | "MerkleRootSealSingles" | "SealSourceCouples" | "SealSourceTriples" | "SealSourceLastSingles" | "BackerRegistrarSealCouples" | "TypedDigestSealCouples" | "BlindedStateQuadruples" | "BoundStateSextuples" | "TypedMediaQuadruples";
/**
 * Digest seal fixed-field value (`d`).
 *
 * KERIpy substance:
 * - named single-value seal used for SAID/digest anchoring
 *
 * Counter family:
 * - `DigestSealSingles`
 */
export type SealDigest = Readonly<{
    d: Diger;
}>;
export declare const SealDigest: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        d: string;
    }>) => Readonly<{
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        d: Diger;
    }>) => Readonly<{
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["d"];
    readonly cast: Readonly<Record<"d", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        d: Diger;
    }>) => readonly [Diger];
    readonly toCrew: (value: Readonly<{
        d: Diger;
    }>) => Readonly<{
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        d: Diger;
    }>) => Uint8Array;
}>;
/**
 * Merkle-root seal fixed-field value (`rd`).
 *
 * KERIpy substance:
 * - named single-value seal for anchored Merkle-tree root digests
 *
 * Counter family:
 * - `MerkleRootSealSingles`
 */
export type SealRoot = Readonly<{
    rd: Diger;
}>;
export declare const SealRoot: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        rd: string;
    }>;
    readonly fromSad: (value: Readonly<{
        rd: string;
    }>) => Readonly<{
        rd: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        rd: Diger;
    }>) => Readonly<{
        rd: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["rd"];
    readonly cast: Readonly<Record<"rd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
        rd: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
        rd: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        rd: Diger;
    }>) => readonly [Diger];
    readonly toCrew: (value: Readonly<{
        rd: Diger;
    }>) => Readonly<{
        rd: string;
    }>;
    readonly qb64: (value: Readonly<{
        rd: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        rd: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        rd: Diger;
    }>) => Uint8Array;
}>;
/**
 * Source seal fixed-field value (`s`, `d`).
 *
 * Maintainer model:
 * - the issuer/delegator prefix is implied by surrounding context
 * - `s` stays a real `NumberPrimitive`; crew/object form projects `.numh`
 *
 * Counter family:
 * - `SealSourceCouples`
 */
export type SealSource = Readonly<{
    s: NumberPrimitive;
    d: Diger;
}>;
export declare const SealSource: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        s: string;
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        s: string;
        d: string;
    }>) => Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => Readonly<{
        s: string;
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["s", "d"];
    readonly cast: Readonly<Record<"d" | "s", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [NumberPrimitive, Diger]) => Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => readonly [NumberPrimitive, Diger];
    readonly toCrew: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => Readonly<{
        s: string;
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => Uint8Array;
}>;
/**
 * Event seal fixed-field value (`i`, `s`, `d`).
 *
 * KERIpy substance:
 * - named triple pointing at one anchoring or delegated key event
 *
 * Counter family:
 * - `SealSourceTriples`
 */
export type SealEvent = Readonly<{
    i: Prefixer;
    s: NumberPrimitive;
    d: Diger;
}>;
export declare const SealEvent: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        i: string;
        s: string;
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        i: string;
        s: string;
        d: string;
    }>) => Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => Readonly<{
        i: string;
        s: string;
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["i", "s", "d"];
    readonly cast: Readonly<Record<"d" | "s" | "i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Prefixer, NumberPrimitive, Diger]) => Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b]) => Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => readonly [Prefixer, NumberPrimitive, Diger];
    readonly toCrew: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => Readonly<{
        i: string;
        s: string;
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => Uint8Array;
}>;
/**
 * Last-establishment lookup seal (`i`).
 *
 * KERIpy substance:
 * - named single-value marker that says "use the latest establishment event
 *   from this prefix"
 *
 * Counter family:
 * - `SealSourceLastSingles`
 */
export type SealLast = Readonly<{
    i: Prefixer;
}>;
export declare const SealLast: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        i: string;
    }>;
    readonly fromSad: (value: Readonly<{
        i: string;
    }>) => Readonly<{
        i: Prefixer;
    }>;
    readonly toSad: (value: Readonly<{
        i: Prefixer;
    }>) => Readonly<{
        i: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["i"];
    readonly cast: Readonly<Record<"i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Prefixer]) => Readonly<{
        i: Prefixer;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
        i: Prefixer;
    }>;
    readonly toTuple: (value: Readonly<{
        i: Prefixer;
    }>) => readonly [Prefixer];
    readonly toCrew: (value: Readonly<{
        i: Prefixer;
    }>) => Readonly<{
        i: string;
    }>;
    readonly qb64: (value: Readonly<{
        i: Prefixer;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        i: Prefixer;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        i: Prefixer;
    }>) => Uint8Array;
}>;
/**
 * Backer/registrar seal fixed-field value (`bi`, `d`).
 *
 * KERIpy substance:
 * - named pair used for registrar/backer references where `bi` is the backer
 *   prefix and `d` is the attached metadata/event digest
 *
 * Counter family:
 * - `BackerRegistrarSealCouples`
 */
export type SealBack = Readonly<{
    bi: Prefixer;
    d: Diger;
}>;
export declare const SealBack: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        bi: string;
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        bi: string;
        d: string;
    }>) => Readonly<{
        bi: Prefixer;
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => Readonly<{
        bi: string;
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["bi", "d"];
    readonly cast: Readonly<Record<"d" | "bi", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Prefixer, Diger]) => Readonly<{
        bi: Prefixer;
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
        bi: Prefixer;
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => readonly [Prefixer, Diger];
    readonly toCrew: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => Readonly<{
        bi: string;
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => Uint8Array;
}>;
/**
 * Typed-digest seal fixed-field value (`t`, `d`).
 *
 * KERIpy substance:
 * - pairs one `Verser` with one digest so typed/versioned digests stay
 *   explicit in counted attachment groups
 *
 * Counter family:
 * - `TypedDigestSealCouples`
 */
export type SealKind = Readonly<{
    t: Verser;
    d: Diger;
}>;
export declare const SealKind: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        t: string;
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        t: string;
        d: string;
    }>) => Readonly<{
        t: Verser;
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => Readonly<{
        t: string;
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["t", "d"];
    readonly cast: Readonly<Record<"d" | "t", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Verser, Diger]) => Readonly<{
        t: Verser;
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
        t: Verser;
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => readonly [Verser, Diger];
    readonly toCrew: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => Readonly<{
        t: string;
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => Uint8Array;
}>;
/**
 * Blind-state fixed-field value (`d`, `u`, `td`, `ts`).
 *
 * Field meanings:
 * - `d`: blinded commitment over the full tuple
 * - `u`: disclosure UUID / nonce that scopes the blinding operation
 * - `td`: disclosed ACDC/TEL SAID, or empty placeholder when not yet revealed
 * - `ts`: disclosed state label, or empty placeholder when not yet revealed
 *
 * TypeScript divergence:
 * - the digest-like slots remain `Noncer`, not `Diger`, so empty-placeholder
 *   state keeps the same expressive range as KERIpy
 *
 * Why `Noncer` instead of `Diger`:
 * - KERIpy treats these slots as placeholder-capable digest material
 * - an empty blind-state field is still meaningful during graduated
 *   disclosure, so the value space must include "present but empty"
 *
 * Counter family:
 * - `BlindedStateQuadruples`
 */
export type BlindState = Readonly<{
    d: Noncer;
    u: Noncer;
    td: Noncer;
    ts: Labeler;
}>;
export declare const BlindState: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        d: string;
        u: string;
        td: string;
        ts: string;
    }>;
    readonly fromSad: (value: Readonly<{
        d: string;
        u: string;
        td: string;
        ts: string;
    }>) => Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
    }>;
    readonly toSad: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
    }>) => Readonly<{
        d: string;
        u: string;
        td: string;
        ts: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["d", "u", "td", "ts"];
    readonly cast: Readonly<Record<"d" | "u" | "td" | "ts", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler]) => Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
    }>;
    readonly toTuple: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
    }>) => readonly [Noncer, Noncer, Noncer, Labeler];
    readonly toCrew: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
    }>) => Readonly<{
        d: string;
        u: string;
        td: string;
        ts: string;
    }>;
    readonly qb64: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
    }>) => Uint8Array;
}>;
/**
 * Bound blind-state fixed-field value (`d`, `u`, `td`, `ts`, `bn`, `bd`).
 *
 * KERIpy substance:
 * - extends blind state with the issuee key-state cross-anchor pair used for
 *   bound-state sextuples
 *
 * Field meanings:
 * - `bn`: issuee key-state sequence number for the cross-anchor
 * - `bd`: issuee key-state digest for the cross-anchor
 *
 * Placeholder semantics:
 * - `bn=0`, `bd=""` is a real placeholder combination used during
 *   graduated-disclosure search and commitment recomputation
 *
 * Counter family:
 * - `BoundStateSextuples`
 */
export type BoundState = Readonly<{
    d: Noncer;
    u: Noncer;
    td: Noncer;
    ts: Labeler;
    bn: NumberPrimitive;
    bd: Noncer;
}>;
export declare const BoundState: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        d: string;
        u: string;
        td: string;
        ts: string;
        bn: string;
        bd: string;
    }>;
    readonly fromSad: (value: Readonly<{
        d: string;
        u: string;
        td: string;
        ts: string;
        bn: string;
        bd: string;
    }>) => Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
        bn: NumberPrimitive;
        bd: Noncer;
    }>;
    readonly toSad: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
        bn: NumberPrimitive;
        bd: Noncer;
    }>) => Readonly<{
        d: string;
        u: string;
        td: string;
        ts: string;
        bn: string;
        bd: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["d", "u", "td", "ts", "bn", "bd"];
    readonly cast: Readonly<Record<"d" | "u" | "td" | "ts" | "bn" | "bd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer]) => Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
        bn: NumberPrimitive;
        bd: Noncer;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
        bn: NumberPrimitive;
        bd: Noncer;
    }>;
    readonly toTuple: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
        bn: NumberPrimitive;
        bd: Noncer;
    }>) => readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer];
    readonly toCrew: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
        bn: NumberPrimitive;
        bd: Noncer;
    }>) => Readonly<{
        d: string;
        u: string;
        td: string;
        ts: string;
        bn: string;
        bd: string;
    }>;
    readonly qb64: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
        bn: NumberPrimitive;
        bd: Noncer;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
        bn: NumberPrimitive;
        bd: Noncer;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        td: Noncer;
        ts: Labeler;
        bn: NumberPrimitive;
        bd: Noncer;
    }>) => Uint8Array;
}>;
/**
 * Typed-media fixed-field value (`d`, `u`, `mt`, `mv`).
 *
 * Maintainer model:
 * - the field names stay KERIpy-exact
 * - callers read primitive projections directly from the fields
 * - `mt` carries the media-type label
 * - `mv` carries the associated media value/payload text
 *
 * Counter family:
 * - `TypedMediaQuadruples`
 */
export type TypeMedia = Readonly<{
    d: Noncer;
    u: Noncer;
    mt: Labeler;
    mv: Texter;
}>;
export declare const TypeMedia: Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        d: string;
        u: string;
        mt: string;
        mv: string;
    }>;
    readonly fromSad: (value: Readonly<{
        d: string;
        u: string;
        mt: string;
        mv: string;
    }>) => Readonly<{
        d: Noncer;
        u: Noncer;
        mt: Labeler;
        mv: Texter;
    }>;
    readonly toSad: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        mt: Labeler;
        mv: Texter;
    }>) => Readonly<{
        d: string;
        u: string;
        mt: string;
        mv: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["d", "u", "mt", "mv"];
    readonly cast: Readonly<Record<"d" | "u" | "mt" | "mv", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Noncer, Noncer, Labeler, Texter]) => Readonly<{
        d: Noncer;
        u: Noncer;
        mt: Labeler;
        mv: Texter;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
        d: Noncer;
        u: Noncer;
        mt: Labeler;
        mv: Texter;
    }>;
    readonly toTuple: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        mt: Labeler;
        mv: Texter;
    }>) => readonly [Noncer, Noncer, Labeler, Texter];
    readonly toCrew: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        mt: Labeler;
        mv: Texter;
    }>) => Readonly<{
        d: string;
        u: string;
        mt: string;
        mv: string;
    }>;
    readonly qb64: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        mt: Labeler;
        mv: Texter;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        mt: Labeler;
        mv: Texter;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        d: Noncer;
        u: Noncer;
        mt: Labeler;
        mv: Texter;
    }>) => Uint8Array;
}>;
/** Empty clan registry placeholder retained for KERIpy naming familiarity. */
export declare const EmptyClanDom: Readonly<{}>;
/** Empty cast registry placeholder retained for KERIpy naming familiarity. */
export declare const EmptyCastDom: Readonly<{}>;
/** KERIpy alias for `EmptyClanDom`. */
export declare const EClanDom: Readonly<{}>;
/** KERIpy alias for `EmptyCastDom`. */
export declare const ECastDom: Readonly<{}>;
/** Seal-struct clan registry (`SealDigest` through `SealKind`). */
export declare const SealClanDom: Readonly<{
    readonly SealDigest: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
        }>) => Readonly<{
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            d: Diger;
        }>) => Readonly<{
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d"];
        readonly cast: Readonly<Record<"d", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Diger;
        }>) => readonly [Diger];
        readonly toCrew: (value: Readonly<{
            d: Diger;
        }>) => Readonly<{
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealRoot: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            rd: string;
        }>;
        readonly fromSad: (value: Readonly<{
            rd: string;
        }>) => Readonly<{
            rd: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            rd: Diger;
        }>) => Readonly<{
            rd: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["rd"];
        readonly cast: Readonly<Record<"rd", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
            rd: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            rd: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            rd: Diger;
        }>) => readonly [Diger];
        readonly toCrew: (value: Readonly<{
            rd: Diger;
        }>) => Readonly<{
            rd: string;
        }>;
        readonly qb64: (value: Readonly<{
            rd: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            rd: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            rd: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealSource: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            s: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            s: string;
            d: string;
        }>) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            s: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["s", "d"];
        readonly cast: Readonly<Record<"d" | "s", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [NumberPrimitive, Diger]) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => readonly [NumberPrimitive, Diger];
        readonly toCrew: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            s: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealEvent: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            i: string;
            s: string;
            d: string;
        }>) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["i", "s", "d"];
        readonly cast: Readonly<Record<"d" | "s" | "i", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer, NumberPrimitive, Diger]) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b]) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => readonly [Prefixer, NumberPrimitive, Diger];
        readonly toCrew: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealLast: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            i: string;
        }>;
        readonly fromSad: (value: Readonly<{
            i: string;
        }>) => Readonly<{
            i: Prefixer;
        }>;
        readonly toSad: (value: Readonly<{
            i: Prefixer;
        }>) => Readonly<{
            i: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["i"];
        readonly cast: Readonly<Record<"i", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer]) => Readonly<{
            i: Prefixer;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            i: Prefixer;
        }>;
        readonly toTuple: (value: Readonly<{
            i: Prefixer;
        }>) => readonly [Prefixer];
        readonly toCrew: (value: Readonly<{
            i: Prefixer;
        }>) => Readonly<{
            i: string;
        }>;
        readonly qb64: (value: Readonly<{
            i: Prefixer;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            i: Prefixer;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            i: Prefixer;
        }>) => Uint8Array;
    }>;
    readonly SealBack: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            bi: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            bi: string;
            d: string;
        }>) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Readonly<{
            bi: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["bi", "d"];
        readonly cast: Readonly<Record<"d" | "bi", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer, Diger]) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => readonly [Prefixer, Diger];
        readonly toCrew: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Readonly<{
            bi: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealKind: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            t: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            t: string;
            d: string;
        }>) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Readonly<{
            t: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["t", "d"];
        readonly cast: Readonly<Record<"d" | "t", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Verser, Diger]) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => readonly [Verser, Diger];
        readonly toCrew: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Readonly<{
            t: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Uint8Array;
    }>;
}>;
/** KERIpy alias for `SealClanDom`. */
export declare const SClanDom: Readonly<{
    readonly SealDigest: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
        }>) => Readonly<{
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            d: Diger;
        }>) => Readonly<{
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d"];
        readonly cast: Readonly<Record<"d", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Diger;
        }>) => readonly [Diger];
        readonly toCrew: (value: Readonly<{
            d: Diger;
        }>) => Readonly<{
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealRoot: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            rd: string;
        }>;
        readonly fromSad: (value: Readonly<{
            rd: string;
        }>) => Readonly<{
            rd: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            rd: Diger;
        }>) => Readonly<{
            rd: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["rd"];
        readonly cast: Readonly<Record<"rd", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
            rd: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            rd: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            rd: Diger;
        }>) => readonly [Diger];
        readonly toCrew: (value: Readonly<{
            rd: Diger;
        }>) => Readonly<{
            rd: string;
        }>;
        readonly qb64: (value: Readonly<{
            rd: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            rd: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            rd: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealSource: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            s: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            s: string;
            d: string;
        }>) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            s: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["s", "d"];
        readonly cast: Readonly<Record<"d" | "s", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [NumberPrimitive, Diger]) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => readonly [NumberPrimitive, Diger];
        readonly toCrew: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            s: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealEvent: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            i: string;
            s: string;
            d: string;
        }>) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["i", "s", "d"];
        readonly cast: Readonly<Record<"d" | "s" | "i", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer, NumberPrimitive, Diger]) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b]) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => readonly [Prefixer, NumberPrimitive, Diger];
        readonly toCrew: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealLast: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            i: string;
        }>;
        readonly fromSad: (value: Readonly<{
            i: string;
        }>) => Readonly<{
            i: Prefixer;
        }>;
        readonly toSad: (value: Readonly<{
            i: Prefixer;
        }>) => Readonly<{
            i: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["i"];
        readonly cast: Readonly<Record<"i", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer]) => Readonly<{
            i: Prefixer;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            i: Prefixer;
        }>;
        readonly toTuple: (value: Readonly<{
            i: Prefixer;
        }>) => readonly [Prefixer];
        readonly toCrew: (value: Readonly<{
            i: Prefixer;
        }>) => Readonly<{
            i: string;
        }>;
        readonly qb64: (value: Readonly<{
            i: Prefixer;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            i: Prefixer;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            i: Prefixer;
        }>) => Uint8Array;
    }>;
    readonly SealBack: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            bi: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            bi: string;
            d: string;
        }>) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Readonly<{
            bi: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["bi", "d"];
        readonly cast: Readonly<Record<"d" | "bi", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer, Diger]) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => readonly [Prefixer, Diger];
        readonly toCrew: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Readonly<{
            bi: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealKind: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            t: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            t: string;
            d: string;
        }>) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Readonly<{
            t: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["t", "d"];
        readonly cast: Readonly<Record<"d" | "t", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Verser, Diger]) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => readonly [Verser, Diger];
        readonly toCrew: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Readonly<{
            t: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Uint8Array;
    }>;
}>;
/** Seal-struct cast registry keyed by clan name. */
export declare const SealCastDom: Readonly<{
    readonly SealDigest: Readonly<Record<"d", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealRoot: Readonly<Record<"rd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealSource: Readonly<Record<"d" | "s", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealEvent: Readonly<Record<"d" | "s" | "i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealLast: Readonly<Record<"i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealBack: Readonly<Record<"d" | "bi", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealKind: Readonly<Record<"d" | "t", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
}>;
/** KERIpy alias for `SealCastDom`. */
export declare const SCastDom: Readonly<{
    readonly SealDigest: Readonly<Record<"d", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealRoot: Readonly<Record<"rd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealSource: Readonly<Record<"d" | "s", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealEvent: Readonly<Record<"d" | "s" | "i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealLast: Readonly<Record<"i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealBack: Readonly<Record<"d" | "bi", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealKind: Readonly<Record<"d" | "t", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
}>;
/** Blind-state clan registry (`BlindState`, `BoundState`). */
export declare const BlindStateClanDom: Readonly<{
    readonly BlindState: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "td", "ts"];
        readonly cast: Readonly<Record<"d" | "u" | "td" | "ts", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => readonly [Noncer, Noncer, Noncer, Labeler];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Uint8Array;
    }>;
    readonly BoundState: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "td", "ts", "bn", "bd"];
        readonly cast: Readonly<Record<"d" | "u" | "td" | "ts" | "bn" | "bd", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Uint8Array;
    }>;
}>;
/** KERIpy alias for `BlindStateClanDom`. */
export declare const BSClanDom: Readonly<{
    readonly BlindState: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "td", "ts"];
        readonly cast: Readonly<Record<"d" | "u" | "td" | "ts", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => readonly [Noncer, Noncer, Noncer, Labeler];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Uint8Array;
    }>;
    readonly BoundState: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "td", "ts", "bn", "bd"];
        readonly cast: Readonly<Record<"d" | "u" | "td" | "ts" | "bn" | "bd", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Uint8Array;
    }>;
}>;
/** Blind-state cast registry keyed by clan name. */
export declare const BlindStateCastDom: Readonly<{
    readonly BlindState: Readonly<Record<"d" | "u" | "td" | "ts", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly BoundState: Readonly<Record<"d" | "u" | "td" | "ts" | "bn" | "bd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
}>;
/** KERIpy alias for `BlindStateCastDom`. */
export declare const BSCastDom: Readonly<{
    readonly BlindState: Readonly<Record<"d" | "u" | "td" | "ts", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly BoundState: Readonly<Record<"d" | "u" | "td" | "ts" | "bn" | "bd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
}>;
/** Typed-media clan registry (`TypeMedia`). */
export declare const TypeMediaClanDom: Readonly<{
    readonly TypeMedia: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "mt", "mv"];
        readonly cast: Readonly<Record<"d" | "u" | "mt" | "mv", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Labeler, Texter]) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => readonly [Noncer, Noncer, Labeler, Texter];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Uint8Array;
    }>;
}>;
/** KERIpy alias for `TypeMediaClanDom`. */
export declare const TMClanDom: Readonly<{
    readonly TypeMedia: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "mt", "mv"];
        readonly cast: Readonly<Record<"d" | "u" | "mt" | "mv", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Labeler, Texter]) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => readonly [Noncer, Noncer, Labeler, Texter];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Uint8Array;
    }>;
}>;
/** Typed-media cast registry keyed by clan name. */
export declare const TypeMediaCastDom: Readonly<{
    readonly TypeMedia: Readonly<Record<"d" | "u" | "mt" | "mv", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
}>;
/** KERIpy alias for `TypeMediaCastDom`. */
export declare const TMCastDom: Readonly<{
    readonly TypeMedia: Readonly<Record<"d" | "u" | "mt" | "mv", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
}>;
/** All structing clan registries combined into one authoritative CESR view. */
export declare const AllClanDom: Readonly<{
    readonly TypeMedia: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "mt", "mv"];
        readonly cast: Readonly<Record<"d" | "u" | "mt" | "mv", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Labeler, Texter]) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => readonly [Noncer, Noncer, Labeler, Texter];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Uint8Array;
    }>;
    readonly BlindState: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "td", "ts"];
        readonly cast: Readonly<Record<"d" | "u" | "td" | "ts", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => readonly [Noncer, Noncer, Noncer, Labeler];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Uint8Array;
    }>;
    readonly BoundState: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "td", "ts", "bn", "bd"];
        readonly cast: Readonly<Record<"d" | "u" | "td" | "ts" | "bn" | "bd", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Uint8Array;
    }>;
    readonly SealDigest: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
        }>) => Readonly<{
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            d: Diger;
        }>) => Readonly<{
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d"];
        readonly cast: Readonly<Record<"d", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Diger;
        }>) => readonly [Diger];
        readonly toCrew: (value: Readonly<{
            d: Diger;
        }>) => Readonly<{
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealRoot: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            rd: string;
        }>;
        readonly fromSad: (value: Readonly<{
            rd: string;
        }>) => Readonly<{
            rd: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            rd: Diger;
        }>) => Readonly<{
            rd: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["rd"];
        readonly cast: Readonly<Record<"rd", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
            rd: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            rd: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            rd: Diger;
        }>) => readonly [Diger];
        readonly toCrew: (value: Readonly<{
            rd: Diger;
        }>) => Readonly<{
            rd: string;
        }>;
        readonly qb64: (value: Readonly<{
            rd: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            rd: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            rd: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealSource: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            s: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            s: string;
            d: string;
        }>) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            s: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["s", "d"];
        readonly cast: Readonly<Record<"d" | "s", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [NumberPrimitive, Diger]) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => readonly [NumberPrimitive, Diger];
        readonly toCrew: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            s: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealEvent: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            i: string;
            s: string;
            d: string;
        }>) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["i", "s", "d"];
        readonly cast: Readonly<Record<"d" | "s" | "i", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer, NumberPrimitive, Diger]) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b]) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => readonly [Prefixer, NumberPrimitive, Diger];
        readonly toCrew: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealLast: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            i: string;
        }>;
        readonly fromSad: (value: Readonly<{
            i: string;
        }>) => Readonly<{
            i: Prefixer;
        }>;
        readonly toSad: (value: Readonly<{
            i: Prefixer;
        }>) => Readonly<{
            i: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["i"];
        readonly cast: Readonly<Record<"i", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer]) => Readonly<{
            i: Prefixer;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            i: Prefixer;
        }>;
        readonly toTuple: (value: Readonly<{
            i: Prefixer;
        }>) => readonly [Prefixer];
        readonly toCrew: (value: Readonly<{
            i: Prefixer;
        }>) => Readonly<{
            i: string;
        }>;
        readonly qb64: (value: Readonly<{
            i: Prefixer;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            i: Prefixer;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            i: Prefixer;
        }>) => Uint8Array;
    }>;
    readonly SealBack: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            bi: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            bi: string;
            d: string;
        }>) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Readonly<{
            bi: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["bi", "d"];
        readonly cast: Readonly<Record<"d" | "bi", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer, Diger]) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => readonly [Prefixer, Diger];
        readonly toCrew: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Readonly<{
            bi: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealKind: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            t: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            t: string;
            d: string;
        }>) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Readonly<{
            t: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["t", "d"];
        readonly cast: Readonly<Record<"d" | "t", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Verser, Diger]) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => readonly [Verser, Diger];
        readonly toCrew: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Readonly<{
            t: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Uint8Array;
    }>;
}>;
/** KERIpy alias for `AllClanDom`. */
export declare const AClanDom: Readonly<{
    readonly TypeMedia: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "mt", "mv"];
        readonly cast: Readonly<Record<"d" | "u" | "mt" | "mv", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Labeler, Texter]) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => readonly [Noncer, Noncer, Labeler, Texter];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Readonly<{
            d: string;
            u: string;
            mt: string;
            mv: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            mt: Labeler;
            mv: Texter;
        }>) => Uint8Array;
    }>;
    readonly BlindState: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "td", "ts"];
        readonly cast: Readonly<Record<"d" | "u" | "td" | "ts", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => readonly [Noncer, Noncer, Noncer, Labeler];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
        }>) => Uint8Array;
    }>;
    readonly BoundState: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly toSad: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d", "u", "td", "ts", "bn", "bd"];
        readonly cast: Readonly<Record<"d" | "u" | "td" | "ts" | "bn" | "bd", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b, Qb64b, Qb64b, Qb64b]) => Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => readonly [Noncer, Noncer, Noncer, Labeler, NumberPrimitive, Noncer];
        readonly toCrew: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Readonly<{
            d: string;
            u: string;
            td: string;
            ts: string;
            bn: string;
            bd: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Noncer;
            u: Noncer;
            td: Noncer;
            ts: Labeler;
            bn: NumberPrimitive;
            bd: Noncer;
        }>) => Uint8Array;
    }>;
    readonly SealDigest: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            d: string;
        }>) => Readonly<{
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            d: Diger;
        }>) => Readonly<{
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["d"];
        readonly cast: Readonly<Record<"d", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            d: Diger;
        }>) => readonly [Diger];
        readonly toCrew: (value: Readonly<{
            d: Diger;
        }>) => Readonly<{
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealRoot: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            rd: string;
        }>;
        readonly fromSad: (value: Readonly<{
            rd: string;
        }>) => Readonly<{
            rd: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            rd: Diger;
        }>) => Readonly<{
            rd: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["rd"];
        readonly cast: Readonly<Record<"rd", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
            rd: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            rd: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            rd: Diger;
        }>) => readonly [Diger];
        readonly toCrew: (value: Readonly<{
            rd: Diger;
        }>) => Readonly<{
            rd: string;
        }>;
        readonly qb64: (value: Readonly<{
            rd: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            rd: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            rd: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealSource: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            s: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            s: string;
            d: string;
        }>) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            s: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["s", "d"];
        readonly cast: Readonly<Record<"d" | "s", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [NumberPrimitive, Diger]) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => readonly [NumberPrimitive, Diger];
        readonly toCrew: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            s: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealEvent: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            i: string;
            s: string;
            d: string;
        }>) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["i", "s", "d"];
        readonly cast: Readonly<Record<"d" | "s" | "i", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer, NumberPrimitive, Diger]) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b]) => Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => readonly [Prefixer, NumberPrimitive, Diger];
        readonly toCrew: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Readonly<{
            i: string;
            s: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            i: Prefixer;
            s: NumberPrimitive;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealLast: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            i: string;
        }>;
        readonly fromSad: (value: Readonly<{
            i: string;
        }>) => Readonly<{
            i: Prefixer;
        }>;
        readonly toSad: (value: Readonly<{
            i: Prefixer;
        }>) => Readonly<{
            i: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["i"];
        readonly cast: Readonly<Record<"i", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer]) => Readonly<{
            i: Prefixer;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
            i: Prefixer;
        }>;
        readonly toTuple: (value: Readonly<{
            i: Prefixer;
        }>) => readonly [Prefixer];
        readonly toCrew: (value: Readonly<{
            i: Prefixer;
        }>) => Readonly<{
            i: string;
        }>;
        readonly qb64: (value: Readonly<{
            i: Prefixer;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            i: Prefixer;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            i: Prefixer;
        }>) => Uint8Array;
    }>;
    readonly SealBack: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            bi: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            bi: string;
            d: string;
        }>) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Readonly<{
            bi: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["bi", "d"];
        readonly cast: Readonly<Record<"d" | "bi", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Prefixer, Diger]) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            bi: Prefixer;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => readonly [Prefixer, Diger];
        readonly toCrew: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Readonly<{
            bi: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            bi: Prefixer;
            d: Diger;
        }>) => Uint8Array;
    }>;
    readonly SealKind: Readonly<{
        readonly isSad: (value: unknown) => value is Readonly<{
            t: string;
            d: string;
        }>;
        readonly fromSad: (value: Readonly<{
            t: string;
            d: string;
        }>) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly toSad: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Readonly<{
            t: string;
            d: string;
        }>;
        readonly name: string;
        readonly fields: readonly ["t", "d"];
        readonly cast: Readonly<Record<"d" | "t", Readonly<{
            kls: new (init: Matter | MatterInit) => StructingPrimitive;
            ipn: string | null;
        }>>>;
        readonly coden: StructingCoden;
        readonly fromTuple: (tuple: readonly [Verser, Diger]) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
            t: Verser;
            d: Diger;
        }>;
        readonly toTuple: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => readonly [Verser, Diger];
        readonly toCrew: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Readonly<{
            t: string;
            d: string;
        }>;
        readonly qb64: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => string;
        readonly qb64b: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Uint8Array;
        readonly qb2: (value: Readonly<{
            t: Verser;
            d: Diger;
        }>) => Uint8Array;
    }>;
}>;
/** All structing cast registries combined into one authoritative CESR view. */
export declare const AllCastDom: Readonly<{
    readonly TypeMedia: Readonly<Record<"d" | "u" | "mt" | "mv", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly BlindState: Readonly<Record<"d" | "u" | "td" | "ts", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly BoundState: Readonly<Record<"d" | "u" | "td" | "ts" | "bn" | "bd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealDigest: Readonly<Record<"d", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealRoot: Readonly<Record<"rd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealSource: Readonly<Record<"d" | "s", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealEvent: Readonly<Record<"d" | "s" | "i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealLast: Readonly<Record<"i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealBack: Readonly<Record<"d" | "bi", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealKind: Readonly<Record<"d" | "t", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
}>;
/** KERIpy alias for `AllCastDom`. */
export declare const ACastDom: Readonly<{
    readonly TypeMedia: Readonly<Record<"d" | "u" | "mt" | "mv", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly BlindState: Readonly<Record<"d" | "u" | "td" | "ts", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly BoundState: Readonly<Record<"d" | "u" | "td" | "ts" | "bn" | "bd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealDigest: Readonly<Record<"d", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealRoot: Readonly<Record<"rd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealSource: Readonly<Record<"d" | "s", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealEvent: Readonly<Record<"d" | "s" | "i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealLast: Readonly<Record<"i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealBack: Readonly<Record<"d" | "bi", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly SealKind: Readonly<Record<"d" | "t", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
}>;
/** All fixed-field structing clan names known to the CESR layer. */
export type StructClanName = keyof typeof AllClanDom;
/** Fixed-field seal union used by typed KERI seal projections. */
export type SealRecord = SealDigest | SealRoot | SealSource | SealEvent | SealLast | SealBack | SealKind;
/** Fixed-field structing record union. */
export type StructingRecord = SealRecord | BlindState | BoundState | TypeMedia;
/** Ordered seal descriptor registry for raw-SAD projection helpers. */
export declare const SealDescriptors: readonly [Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        d: string;
    }>) => Readonly<{
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        d: Diger;
    }>) => Readonly<{
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["d"];
    readonly cast: Readonly<Record<"d", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        d: Diger;
    }>) => readonly [Diger];
    readonly toCrew: (value: Readonly<{
        d: Diger;
    }>) => Readonly<{
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        d: Diger;
    }>) => Uint8Array;
}>, Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        rd: string;
    }>;
    readonly fromSad: (value: Readonly<{
        rd: string;
    }>) => Readonly<{
        rd: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        rd: Diger;
    }>) => Readonly<{
        rd: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["rd"];
    readonly cast: Readonly<Record<"rd", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Diger]) => Readonly<{
        rd: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
        rd: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        rd: Diger;
    }>) => readonly [Diger];
    readonly toCrew: (value: Readonly<{
        rd: Diger;
    }>) => Readonly<{
        rd: string;
    }>;
    readonly qb64: (value: Readonly<{
        rd: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        rd: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        rd: Diger;
    }>) => Uint8Array;
}>, Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        s: string;
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        s: string;
        d: string;
    }>) => Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => Readonly<{
        s: string;
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["s", "d"];
    readonly cast: Readonly<Record<"d" | "s", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [NumberPrimitive, Diger]) => Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => readonly [NumberPrimitive, Diger];
    readonly toCrew: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => Readonly<{
        s: string;
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        s: NumberPrimitive;
        d: Diger;
    }>) => Uint8Array;
}>, Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        i: string;
        s: string;
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        i: string;
        s: string;
        d: string;
    }>) => Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => Readonly<{
        i: string;
        s: string;
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["i", "s", "d"];
    readonly cast: Readonly<Record<"d" | "s" | "i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Prefixer, NumberPrimitive, Diger]) => Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b, Qb64b]) => Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => readonly [Prefixer, NumberPrimitive, Diger];
    readonly toCrew: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => Readonly<{
        i: string;
        s: string;
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        i: Prefixer;
        s: NumberPrimitive;
        d: Diger;
    }>) => Uint8Array;
}>, Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        i: string;
    }>;
    readonly fromSad: (value: Readonly<{
        i: string;
    }>) => Readonly<{
        i: Prefixer;
    }>;
    readonly toSad: (value: Readonly<{
        i: Prefixer;
    }>) => Readonly<{
        i: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["i"];
    readonly cast: Readonly<Record<"i", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Prefixer]) => Readonly<{
        i: Prefixer;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b]) => Readonly<{
        i: Prefixer;
    }>;
    readonly toTuple: (value: Readonly<{
        i: Prefixer;
    }>) => readonly [Prefixer];
    readonly toCrew: (value: Readonly<{
        i: Prefixer;
    }>) => Readonly<{
        i: string;
    }>;
    readonly qb64: (value: Readonly<{
        i: Prefixer;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        i: Prefixer;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        i: Prefixer;
    }>) => Uint8Array;
}>, Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        bi: string;
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        bi: string;
        d: string;
    }>) => Readonly<{
        bi: Prefixer;
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => Readonly<{
        bi: string;
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["bi", "d"];
    readonly cast: Readonly<Record<"d" | "bi", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Prefixer, Diger]) => Readonly<{
        bi: Prefixer;
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
        bi: Prefixer;
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => readonly [Prefixer, Diger];
    readonly toCrew: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => Readonly<{
        bi: string;
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        bi: Prefixer;
        d: Diger;
    }>) => Uint8Array;
}>, Readonly<{
    readonly isSad: (value: unknown) => value is Readonly<{
        t: string;
        d: string;
    }>;
    readonly fromSad: (value: Readonly<{
        t: string;
        d: string;
    }>) => Readonly<{
        t: Verser;
        d: Diger;
    }>;
    readonly toSad: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => Readonly<{
        t: string;
        d: string;
    }>;
    readonly name: string;
    readonly fields: readonly ["t", "d"];
    readonly cast: Readonly<Record<"d" | "t", Readonly<{
        kls: new (init: Matter | MatterInit) => StructingPrimitive;
        ipn: string | null;
    }>>>;
    readonly coden: StructingCoden;
    readonly fromTuple: (tuple: readonly [Verser, Diger]) => Readonly<{
        t: Verser;
        d: Diger;
    }>;
    readonly fromQb64bTuple: (tuple: readonly [Qb64b, Qb64b]) => Readonly<{
        t: Verser;
        d: Diger;
    }>;
    readonly toTuple: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => readonly [Verser, Diger];
    readonly toCrew: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => Readonly<{
        t: string;
        d: string;
    }>;
    readonly qb64: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => string;
    readonly qb64b: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => Uint8Array;
    readonly qb2: (value: Readonly<{
        t: Verser;
        d: Diger;
    }>) => Uint8Array;
}>];
/**
 * Authoritative clan-name -> semantic counter-name map for structing families.
 *
 * This mirrors KERIpy `ClanToCodens`, but stores semantic counter names rather
 * than Python codex members.
 */
export declare const ClanToCodens: Readonly<{
    readonly SealDigest: StructingCoden;
    readonly SealRoot: StructingCoden;
    readonly SealSource: StructingCoden;
    readonly SealEvent: StructingCoden;
    readonly SealLast: StructingCoden;
    readonly SealBack: StructingCoden;
    readonly SealKind: StructingCoden;
    readonly BlindState: StructingCoden;
    readonly BoundState: StructingCoden;
    readonly TypeMedia: StructingCoden;
}>;
/** Inverse semantic counter-name -> clan-name registry for structing families. */
export declare const CodenToClans: Readonly<Record<StructingCoden, "SealDigest" | "SealRoot" | "SealSource" | "SealEvent" | "SealLast" | "SealBack" | "SealKind" | "BlindState" | "BoundState" | "TypeMedia">>;
export {};
//# sourceMappingURL=structing.d.ts.map