cesr-ts 0.4.0 → 0.6.0

package/types/src/primitives/structing.d.ts

@@ -0,0 +1,4114 @@
+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