@nvisy/sdk 0.25.0 → 0.26.0

package/dist/{index-Cijg5CMy.d.ts → index-Zd5G8h44.d.ts}

@@ -8129,7 +8129,7 @@ interface components {
      *     UUID, a jurisdiction) is that layer's concern — it can encode it in the
      *     name or carry it separately.
      *
-     *     [`Redaction`]: crate::entity::provenance::EventKind::Redaction
+     *     [`Redaction`]: crate::entity::audit::AuditKind::Redaction
      */
     Attribution: {
       /** @description Human-readable description (e.g. `"right to erasure"`), when given. */
@@ -8138,170 +8138,90 @@ interface components {
       name: string;
     };
     /**
-     * @description Per-call payload a recognizer inspects for the [`Audio`] modality.
-     *
-     *     Carries the encoded audio bytes; an optional filename aids diagnostics
-     *     and encoding inference (the container format a decoder should expect).
-     *     The recognizable text — a timestamped transcript — is *not* held here;
-     *     a speech-to-text [`Enricher`] stamps it onto the call's
-     *     [`artifacts`], keeping
-     *     `AudioData` the codec's payload alone.
-     *
-     *     [`Audio`]: super::Audio
-     *     [`Enricher`]: crate::recognition::Enricher
-     *     [`artifacts`]: crate::recognition::RecognizerContext::artifacts
-     */
-    AudioData: {
-      /** @description Original filename, when known. */
-      filename?: string;
-    };
-    /**
-     * @description Detected piece of sensitive information within some medium.
+     * @description One node in an entity's audit DAG: a thing that happened, with its
+     *     effect on confidence and its tamper-evident links.
      *
-     *     Generic over the [`Modality`] `M`, which is what makes the model
-     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
-     *     `Entity<Audio>`, and so on. The entity's location is the modality's
-     *     [`Location`] type, `M::Location`.
+     *     Events are recorded on an entity's [`AuditLog`], forming the full audit
+     *     trail of its life: each recognizer that found it, the deduplication that
+     *     fused them, any score calibration, and the redaction that hid it. The
+     *     uniform spine (who, resulting score, when) is the same for every event; the
+     *     [`kind`] carries the event-specific detail *and* the explanation of why the
+     *     event happened.
      *
-     *     # Birth and fusion
+     *     Each event links to its [`parents`] by their [`hash`]: a birth event (a
+     *     recognizer's first detection) has no parents, a normal step has one, and a
+     *     [fusion](crate::entity::audit::AuditLog::record_fusion) has several. Its own
+     *     [`hash`] folds the
+     *     payload together with the parents' hashes, so altering any event breaks
+     *     every event downstream of it: [`AuditLog::verify`] walks the DAG and
+     *     reports the first break.
      *
-     *     A recognizer emits an entity directly, carrying a single recognition
-     *     [`Event`] (its own finding) in the entity's [`provenance`]. When
-     *     several recognizers find the same thing, a fusion step (in
-     *     `elide`) combines their entities into one: the survivor's
-     *     [`location`] and [`confidence`] are the *fused* values, and every
-     *     contributing recognition event, plus a deduplication event, is
-     *     retained in its provenance. The entity therefore carries its full
-     *     audit trail with it.
+     *     `entity.confidence` always equals the [`confidence`] of the most recent
+     *     event. The confidence *flowing in* is not stored: it is the parents'
+     *     [`confidence`], recovered from the DAG.
      *
-     *     [`Location`]: Modality::Location
-     *     [`Event`]: crate::entity::provenance::Event
-     *     [`provenance`]: Entity::provenance
-     *     [`location`]: Entity::location
-     *     [`confidence`]: Entity::confidence
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
+     *     [`AuditLog::verify`]: crate::entity::audit::AuditLog::verify
+     *     [`kind`]: AuditEvent::kind
+     *     [`parents`]: AuditEvent::parents
+     *     [`hash`]: AuditEvent::hash
+     *     [`confidence`]: AuditEvent::confidence
      */
-    AudioEntity: {
-      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
-      confidence: components["schemas"]["Confidence"];
-      /**
-       * @description Coreference identifier, if a recognizer resolved this entity as one
-       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
-       *     same real-world thing.
-       */
-      coref?: components["schemas"]["EntityCoRef"];
-      /**
-       * Format: uuid
-       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
-       *     when the entity is assembled.
-       */
-      id: string;
+    AudioAuditEvent: {
       /**
-       * @description What kind of sensitive information this is (resolved via a
-       *     [`LabelCatalog`]).
-       */
-      label: components["schemas"]["LabelRef"];
-      /**
-       * @description The language of this entity's surrounding text, when a recognizer
-       *     resolved one. `None` when unknown or language-agnostic.
-       */
-      language?: string;
-      /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      location: components["schemas"]["AudioLocation"];
-      /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
-       */
-      provenance: components["schemas"]["AudioProvenance"];
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description Byte range of the match in the *recognized text* it was found in (the
-       *     OCR layout text, the audio transcript, or the text payload itself) —
-       *     the stable key back into that enrichment artifact, where the rich
-       *     context lives (which OCR block, which speaker) that the geometric
-       *     [`location`] cannot hold. `None` for entities not found via text
-       *     recognition (e.g. a VLM box). Provenance, not a coordinate: redaction
-       *     uses [`location`]; an audit uses this with the artifact.
+       * @description This event's hash, over its payload and its parents' hashes. Assigned by
+       *     [`AuditLog`] when the event is recorded; read it through
+       *     [`hash`](Self::hash). Recomputing it is how the DAG is verified.
        *
-       *     [`location`]: Entity::location
-       */
-      recognized_range?: components["schemas"]["Range_of_uint"];
-    };
-    /**
-     * @description One recognized entity plus the optional reviewer override.
-     *
-     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
-     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
-     *     derivation needs them schema-able. All four modalities elide
-     *     ships satisfy these under the `serde` + `schema` features.
-     */
-    AudioEntityRecord: {
-      /** @description The elide entity, as recognition produced it. */
-      entity: components["schemas"]["AudioEntity"];
-      /**
-       * @description Reviewer-supplied redaction override.
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
        *
-       *     `None` means "use the matching policy rule's decision";
-       *     `Some(...)` overrides that rule for this specific entity
-       *     at apply time. Reviewer overrides take precedence over
-       *     every policy rule and inherit the authority of the
-       *     [`Review::policy_id`] they name — the audit event's
-       *     attribution stamps that policy so the trail names the
-       *     authority under which the override fired.
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      review?: components["schemas"]["Review"];
-    };
-    /**
-     * @description One thing that happened to an entity, with its effect on confidence.
-     *
-     *     Events are recorded in order on an entity's [`Provenance`], forming
-     *     the full audit trail of its life: each recognizer that found it, the
-     *     deduplication that fused them, any score calibration, and the
-     *     redaction that hid it. The uniform spine (who, before/after score,
-     *     when, why) is the same for every event; the [`kind`] carries the
-     *     event-specific detail.
-     *
-     *     `entity.confidence` always equals the [`after`] of the most recent
-     *     event.
-     *
-     *     [`Provenance`]: crate::entity::provenance::Provenance
-     *     [`kind`]: Event::kind
-     *     [`after`]: Event::after
-     */
-    AudioEvent: {
-      /** @description Confidence after this event. */
-      after: components["schemas"]["Confidence"];
-      /** @description When the event happened (UTC). */
-      at: string;
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["AudioAuditKind"];
       /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
+       * @description The events this one follows, by their hash. Empty for a birth event, one
+       *     entry for a normal step, several for a fusion. Assigned by [`AuditLog`]
+       *     when the event is recorded; read it through [`parents`](Self::parents).
+       *
+       *     Not publicly settable: the links are the tamper-evident structure, so
+       *     only [`AuditLog::record`] / [`AuditLog::record_fusion`] assign them.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
+       *     [`AuditLog::record`]: crate::entity::audit::AuditLog::record
+       *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
        */
-      before?: components["schemas"]["Confidence"];
-      /** @description Kind of event, with its event-specific detail. */
-      kind: components["schemas"]["AudioEventKind"];
-      /** @description Free-text explanation of what the event did and why. */
-      reason: string;
+      parents: components["schemas"]["AuditHash"][];
       /**
        * @description Who produced this event: a recognizer name, a deduplication strategy,
        *     an operator, or whatever acted.
        */
       source: string;
+      /** @description When the event happened (UTC). */
+      timestamp: string;
     };
     /**
-     * @description Kind of an [`Event`], carrying its event-specific detail.
+     * @description Kind of an [`AuditEvent`], carrying its event-specific detail and the
+     *     rationale for why it happened.
      *
      *     `#[non_exhaustive]`: new event kinds (verification, annotation, …)
      *     can be added compatibly. The recognition kinds ([`Pattern`],
      *     [`Model`]) carry the matched [`Location`]; the rest carry their own
      *     data.
      *
-     *     [`Pattern`]: EventKind::Pattern
-     *     [`Model`]: EventKind::Model
+     *     [`Pattern`]: AuditKind::Pattern
+     *     [`Model`]: AuditKind::Model
      *     [`Location`]: Modality::Location
      */
-    AudioEventKind: {
+    AudioAuditKind: {
       /** @constant */
       kind: "pattern";
       /** @description Where the recognizer matched. */
@@ -8365,7 +8285,7 @@ interface components {
        *     it is the keyword resolved through the modality's [`locate`] (a
        *     pixel box for image, a time span for audio, the byte range for
        *     text/tabular). `None` when the keyword's stream range could not be
-       *     placed — symmetric with a match the recognizer itself drops.
+       *     placed, symmetric with a match the recognizer itself drops.
        *
        *     [`locate`]: crate::modality::TextRecognizable::locate
        */
@@ -8383,12 +8303,176 @@ interface components {
       /** @description How much the output leaks about the original. */
       leak_profile: components["schemas"]["LeakProfile"];
       /**
-       * @description Which selection rule chose this operator — the automatic "why"
+       * @description Which selection rule chose this operator: the automatic "why"
        *     (matched a label, a tag, a predicate, or the fallback).
        */
       matched_by: components["schemas"]["RuleMatch"];
       /** @description Which operator (name + version) ran. */
       operator: components["schemas"]["OperatorId"];
+      /**
+       * @description BLAKE3 digest of the original text the operator hid, when the
+       *     redaction layer recorded it. Proves *what* was redacted without
+       *     storing the plaintext; `None` when the operator did not capture it.
+       */
+      span_hash?: components["schemas"]["AuditHash"];
+      /**
+       * Format: uint32
+       * @description Byte length of the original text the operator hid, paired with
+       *     [`span_hash`](Self::Redaction::span_hash). `None` when not captured.
+       */
+      span_length?: number;
+    };
+    /**
+     * @description Full audit trail of an [`Entity`]: every [`AuditEvent`] in its life, as a
+     *     tamper-evident DAG.
+     *
+     *     Where Presidio keeps a shallow, optional, per-stage explanation that is
+     *     stripped by default, an `AuditLog` is always present and records the
+     *     entity's *entire* life: each recognizer that found it, the deduplication
+     *     that fused them, any confidence calibration, and the redaction that hid it.
+     *     Nothing is collapsed: every recognizer keeps its own recognition event with
+     *     its location and score.
+     *
+     *     The events form a **directed acyclic graph**, not a flat list. A recognizer
+     *     records a birth event (no parents); each later step links to the event it
+     *     follows; and a [fusion](Self::record_fusion) links to *several* parents at
+     *     once: the heads of the trails it combines. This is the true shape of a
+     *     deduplicated entity: two recognizers are siblings, then a fusion joins them.
+     *     The events are stored in the order they were recorded, which is a
+     *     topological order of the DAG (a parent is always recorded before its
+     *     children).
+     *
+     *     Two chains ride the DAG's edges:
+     *
+     *     - a **confidence chain**, where each event's [`confidence`] is the entity's
+     *       effective score after it; the score flowing *in* is its parents'
+     *       confidence, so [`final_confidence`] and the full history are recoverable;
+     *     - a **hash chain**, where each event's [`hash`] folds its payload together
+     *       with its parents' hashes, so any edit, reorder, insertion, or deletion of
+     *       an earlier event breaks every event downstream. [`verify`] walks the DAG
+     *       and reports the first break.
+     *
+     *     [`Entity`]: crate::entity::Entity
+     *     [`confidence`]: AuditEvent::confidence
+     *     [`hash`]: AuditEvent::hash
+     *     [`final_confidence`]: Self::final_confidence
+     *     [`verify`]: Self::verify
+     */
+    AudioAuditLog: components["schemas"]["AudioAuditEvent"][];
+    /**
+     * @description Per-call payload a recognizer inspects for the [`Audio`] modality.
+     *
+     *     Carries the encoded audio bytes; an optional filename aids diagnostics
+     *     and encoding inference (the container format a decoder should expect).
+     *     The recognizable text — a timestamped transcript — is *not* held here;
+     *     a speech-to-text [`Enricher`] stamps it onto the call's
+     *     [`artifacts`], keeping
+     *     `AudioData` the codec's payload alone.
+     *
+     *     [`Audio`]: super::Audio
+     *     [`Enricher`]: crate::recognition::Enricher
+     *     [`artifacts`]: crate::recognition::RecognizerContext::artifacts
+     */
+    AudioData: {
+      /** @description Original filename, when known. */
+      filename?: string;
+    };
+    /**
+     * @description Detected piece of sensitive information within some medium.
+     *
+     *     Generic over the [`Modality`] `M`, which is what makes the model
+     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
+     *     `Entity<Audio>`, and so on. The entity's location is the modality's
+     *     [`Location`] type, `M::Location`.
+     *
+     *     # Birth and fusion
+     *
+     *     A recognizer emits an entity directly, carrying a single recognition
+     *     [`AuditEvent`] (its own finding) in the entity's [`audit`] trail. When
+     *     several recognizers find the same thing, a fusion step (in
+     *     `elide`) combines their entities into one: the survivor's
+     *     [`location`] and [`confidence`] are the *fused* values, and every
+     *     contributing recognition event, plus a deduplication event, is
+     *     retained in its audit trail. The entity therefore carries its full
+     *     audit trail with it.
+     *
+     *     [`Location`]: Modality::Location
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     *     [`audit`]: Entity::audit
+     *     [`location`]: Entity::location
+     *     [`confidence`]: Entity::confidence
+     */
+    AudioEntity: {
+      /**
+       * @description Tamper-evident audit trail: every contributing detection, the fusion
+       *     event if any, and the redaction that hid it, as a hash-linked DAG.
+       */
+      audit: components["schemas"]["AudioAuditLog"];
+      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
+      confidence: components["schemas"]["Confidence"];
+      /**
+       * @description Coreference identifier, if a recognizer resolved this entity as one
+       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
+       *     same real-world thing.
+       */
+      coref?: components["schemas"]["EntityCoRef"];
+      /**
+       * Format: uuid
+       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
+       *     when the entity is assembled.
+       */
+      id: string;
+      /**
+       * @description What kind of sensitive information this is (resolved via a
+       *     [`LabelCatalog`]).
+       */
+      label: components["schemas"]["LabelRef"];
+      /**
+       * @description The language of this entity's surrounding text, when a recognizer
+       *     resolved one. `None` when unknown or language-agnostic.
+       */
+      language?: string;
+      /**
+       * @description Location of the entity within the medium (fused, if it came from more
+       *     than one detection).
+       */
+      location: components["schemas"]["AudioLocation"];
+      /**
+       * @description Byte range of the match in the *recognized text* it was found in (the
+       *     OCR layout text, the audio transcript, or the text payload itself) —
+       *     the stable key back into that enrichment artifact, where the rich
+       *     context lives (which OCR block, which speaker) that the geometric
+       *     [`location`] cannot hold. `None` for entities not found via text
+       *     recognition (e.g. a VLM box). An audit key, not a coordinate: redaction
+       *     uses [`location`]; an audit uses this with the artifact.
+       *
+       *     [`location`]: Entity::location
+       */
+      recognized_range?: components["schemas"]["Range_of_uint"];
+    };
+    /**
+     * @description One recognized entity plus the optional reviewer override.
+     *
+     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
+     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
+     *     derivation needs them schema-able. All four modalities elide
+     *     ships satisfy these under the `serde` + `schema` features.
+     */
+    AudioEntityRecord: {
+      /** @description The elide entity, as recognition produced it. */
+      entity: components["schemas"]["AudioEntity"];
+      /**
+       * @description Reviewer-supplied redaction override.
+       *
+       *     `None` means "use the matching policy rule's decision";
+       *     `Some(...)` overrides that rule for this specific entity
+       *     at apply time. Reviewer overrides take precedence over
+       *     every policy rule and inherit the authority of the
+       *     [`Review::policy_id`] they name — the audit event's
+       *     attribution stamps that policy so the trail names the
+       *     authority under which the override fired.
+       */
+      review?: components["schemas"]["Review"];
     };
     /**
      * @description Located, typed piece of context a recognizer may treat as in-context
@@ -8430,31 +8514,6 @@ interface components {
       /** @description Diarization label of the speaker, when a diarizer assigned one. */
       speaker_id?: string;
     };
-    /**
-     * @description Full audit trail of an [`Entity`]: every [`Event`] in its life, in
-     *     order.
-     *
-     *     This is the model's answer to "full provenance": where Presidio keeps
-     *     a shallow, optional, per-stage explanation that is stripped by
-     *     default, a `Provenance` is always present and records the entity's
-     *     *entire* life as an ordered list of events: each recognizer that
-     *     found it, the deduplication that fused them, any confidence
-     *     calibration, and the redaction that hid it. Nothing is collapsed:
-     *     every recognizer keeps its own recognition event with its location
-     *     and score.
-     *
-     *     The events form a confidence chain (each event's [`after`] is the
-     *     next's [`before`]) so the final confidence and its full history are
-     *     always recoverable.
-     *
-     *     [`Entity`]: crate::entity::Entity
-     *     [`after`]: Event::after
-     *     [`before`]: Event::before
-     */
-    AudioProvenance: {
-      /** @description Events, in the order they happened. */
-      events: components["schemas"]["AudioEvent"][];
-    };
     /** @description Operator spec a `redact` audio rule carries. */
     AudioRedaction: {
       /** @constant */
@@ -8611,6 +8670,21 @@ interface components {
        */
       ocrMode: components["schemas"]["OcrMode"];
     };
+    /**
+     * @description A 32-byte BLAKE3 digest.
+     *
+     *     The tamper-evident link in an [`AuditLog`] DAG: each [`AuditEvent`] hashes
+     *     its payload together with its parents' hashes, so altering any event breaks
+     *     every event downstream of it. Displays and (with the `serde` feature)
+     *     (de)serializes as lowercase hex.
+     *
+     *     The all-zero hash is [`GENESIS`](AuditHash::GENESIS), the link a birth event
+     *     (one with no parents) chains from.
+     *
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     */
+    AuditHash: string;
     /** @description Response returned after successful authentication (login/signup). */
     AuthToken: {
       /** @description The JWT API token for authentication. */
@@ -8690,6 +8764,24 @@ interface components {
       /** @description Minimum corner (top-left, conventionally). */
       min: components["schemas"]["Point"];
     };
+    /**
+     * @description The coarse group a [`Label`] belongs to, for organizing detected entities
+     *     by kind (`financial`, `health`, `identity`, …).
+     *
+     *     A category answers "what *sort* of information is this" at a display level:
+     *     a consumer groups a redaction audit into sections by category. It is
+     *     distinct from a label's [`tags`], which are cross-cutting sensitivity
+     *     markers (`pii`, `phi`, `pci`) a label may carry several of; a label has at
+     *     most **one** category. Built-in labels ship with a category; a custom
+     *     [`Label`] has none unless one is set.
+     *
+     *     The value is an open, lowercase `snake_case` identifier, so a custom label
+     *     can define its own category rather than being confined to the shipped set.
+     *
+     *     [`Label`]: super::Label
+     *     [`tags`]: super::Label::tags
+     */
+    Category: string;
     /**
      * @description Text a [`TextRedaction::Clamp`] emits for out-of-range values.
      *
@@ -8750,7 +8842,7 @@ interface components {
      * Format: float
      * @description Confidence score in the closed range `0.0..=1.0`.
      *
-     *     Carried by every provenance [`Event`] (the `before`/`after` of a
+     *     Carried by every provenance [`AuditEvent`] (the `before`/`after` of a
      *     recognition, fusion, or calibration) and by the effective confidence
      *     of an [`Entity`]. The newtype enforces the range at construction so
      *     no downstream code has to defend against values outside `[0, 1]`.
@@ -8760,7 +8852,7 @@ interface components {
      *     *cutoff* configured to filter scores. Compare the two with
      *     [`ConfidenceThreshold::passes`].
      *
-     *     [`Event`]: crate::entity::provenance::Event
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
      *     [`Entity`]: crate::entity::Entity
      */
     Confidence: number;
@@ -9384,6 +9476,29 @@ interface components {
        */
       serviceAccountPath: string;
     };
+    /**
+     * @description The GDPR Article 9 template config — treatment axis fused
+     *     with sensitive-scope axis. Carried directly by
+     *     [`crate::PolicyTemplate::GdprArticle9`].
+     */
+    GdprArticle9: {
+      /**
+       * @description Which sensitive-data labels to cover. Defaults to
+       *     [`GdprSensitiveScope::Article9`] (nine Article 9(1)
+       *     categories only). Pick
+       *     [`GdprSensitiveScope::Article9WithReidHardening`] to add
+       *     Recital 26 quasi-identifiers, or
+       *     [`GdprSensitiveScope::Article9And10`] to also cover
+       *     Article 10 criminal-justice data.
+       * @default article9
+       */
+      scope: components["schemas"]["GdprSensitiveScope"];
+      /**
+       * @description Which operator to apply to matches. See
+       *     [`GdprArticle9Treatment`] for the tradeoff.
+       */
+      treatment: components["schemas"]["GdprArticle9Treatment"];
+    };
     /**
      * @description Which operator to apply to Article 9 special-category entities.
      *
@@ -9398,6 +9513,31 @@ interface components {
      *       obligation to establish and document.
      */
     GdprArticle9Treatment: "erase" | "pseudonymize";
+    /**
+     * @description Which sensitive-data labels the template's group covers.
+     *
+     *     Three tiers, each strictly widening the previous one so a
+     *     caller upgrading through the tiers never loses coverage:
+     *
+     *     - [`Article9`](Self::Article9) — the nine Article 9(1)
+     *       special categories only. The default.
+     *     - [`Article9WithReidHardening`](Self::Article9WithReidHardening) —
+     *       Article 9 plus `date_of_birth` and `postal_code`. The two
+     *       quasi-identifiers Recital 26 highlights as re-identification
+     *       vectors when combined with special-category data. Non-
+     *       binding guidance, but reflects supervisory-authority
+     *       expectations on pseudonymization robustness.
+     *     - [`Article9And10`](Self::Article9And10) — Article 9 + Recital
+     *       26 hardening + Article 10's criminal-justice labels
+     *       (`criminal_record`, `criminal_charge`, `judicial_narrative`).
+     *       Article 10 governs "personal data relating to criminal
+     *       convictions and offences", processed only under authorized
+     *       official-authority control or specific Union/Member-State
+     *       law. Callers with criminal-justice adjacency (background-
+     *       check services, court-records handling, HR compliance) pick
+     *       this tier.
+     */
+    GdprSensitiveScope: "article9" | "article9_with_reid_hardening" | "article9_and10";
     /** @description Request to generate a shareable invite code for a workspace. */
     GenerateInviteCode: {
       /** @description When the invite code expires. */
@@ -9418,6 +9558,29 @@ interface components {
     };
     /** @description Operational status of a service component. */
     HealthStatus: "healthy" | "degraded" | "unhealthy";
+    /**
+     * @description Which account-identifier labels §164.514(b)(2)(i)(J) covers.
+     *
+     *     The regulation names "account numbers" without enumerating
+     *     them; HHS OCR's 2012 guidance doesn't narrow it either. In
+     *     practice, covered entities and de-ID vendors treat bank
+     *     accounts, IBANs, and payment cards as the core §(J) set —
+     *     [`Standard`](Self::Standard). Cryptocurrency wallet addresses
+     *     are the newer case: they identify a specific holder's account
+     *     by function, and the §(R) catch-all pulls in "any other unique
+     *     identifying number, characteristic, or code" tied to an
+     *     individual, which arguably captures them. Deployments where
+     *     crypto addresses can appear in patient-facing artifacts pick
+     *     [`Extended`](Self::Extended); deployments where they can't
+     *     stay on `Standard`.
+     *
+     *     The compliant posture for anything account-shaped is
+     *     "remove"; the split is only about how broadly this template
+     *     pre-declares the account label scope. A caller who wants
+     *     broader coverage combines this template's policy with a
+     *     separate PII scope on the same request.
+     */
+    HipaaAccountNumbers: "standard" | "extended";
     /**
      * @description Which HIPAA §164.514 de-identification method to apply.
      *
@@ -9443,168 +9606,111 @@ interface components {
      */
     HipaaDeidMethod: "safe_harbor" | "limited_data_set" | "expert_determination";
     /**
-     * @description Per-call payload a recognizer inspects for the [`Image`] modality.
-     *
-     *     Carries the encoded bytes plus the pixel [`Dimensions`], which a
-     *     recognizer that emits unit-square boxes needs to scale them into pixel
-     *     coordinates. An optional filename aids diagnostics and encoding
-     *     inference.
-     *
-     *     [`Image`]: super::Image
+     * @description The HIPAA §164.514 template config — method axis fused with
+     *     account-identifier axis. Carried directly by
+     *     [`crate::PolicyTemplate::HipaaDeidentification`].
      */
-    ImageData: {
-      /** @description Pixel dimensions of the encoded image. */
-      dimensions: components["schemas"]["Dimensions"];
-      /** @description Original filename, when known. */
-      filename?: string;
+    HipaaDeidentification: {
+      /**
+       * @description Which §(J) account-identifier labels to remove. Defaults
+       *     to [`HipaaAccountNumbers::Standard`] (bank account +
+       *     IBAN + payment card). Pick
+       *     [`HipaaAccountNumbers::Extended`] to add crypto wallet
+       *     addresses under the §(R) catch-all reading.
+       * @default standard
+       */
+      accounts: components["schemas"]["HipaaAccountNumbers"];
+      /**
+       * @description Which §164.514 method to apply. See [`HipaaDeidMethod`]
+       *     for the tradeoff.
+       */
+      method: components["schemas"]["HipaaDeidMethod"];
     };
     /**
-     * @description Detected piece of sensitive information within some medium.
+     * @description One node in an entity's audit DAG: a thing that happened, with its
+     *     effect on confidence and its tamper-evident links.
      *
-     *     Generic over the [`Modality`] `M`, which is what makes the model
-     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
-     *     `Entity<Audio>`, and so on. The entity's location is the modality's
-     *     [`Location`] type, `M::Location`.
+     *     Events are recorded on an entity's [`AuditLog`], forming the full audit
+     *     trail of its life: each recognizer that found it, the deduplication that
+     *     fused them, any score calibration, and the redaction that hid it. The
+     *     uniform spine (who, resulting score, when) is the same for every event; the
+     *     [`kind`] carries the event-specific detail *and* the explanation of why the
+     *     event happened.
      *
-     *     # Birth and fusion
+     *     Each event links to its [`parents`] by their [`hash`]: a birth event (a
+     *     recognizer's first detection) has no parents, a normal step has one, and a
+     *     [fusion](crate::entity::audit::AuditLog::record_fusion) has several. Its own
+     *     [`hash`] folds the
+     *     payload together with the parents' hashes, so altering any event breaks
+     *     every event downstream of it: [`AuditLog::verify`] walks the DAG and
+     *     reports the first break.
      *
-     *     A recognizer emits an entity directly, carrying a single recognition
-     *     [`Event`] (its own finding) in the entity's [`provenance`]. When
-     *     several recognizers find the same thing, a fusion step (in
-     *     `elide`) combines their entities into one: the survivor's
-     *     [`location`] and [`confidence`] are the *fused* values, and every
-     *     contributing recognition event, plus a deduplication event, is
-     *     retained in its provenance. The entity therefore carries its full
-     *     audit trail with it.
+     *     `entity.confidence` always equals the [`confidence`] of the most recent
+     *     event. The confidence *flowing in* is not stored: it is the parents'
+     *     [`confidence`], recovered from the DAG.
      *
-     *     [`Location`]: Modality::Location
-     *     [`Event`]: crate::entity::provenance::Event
-     *     [`provenance`]: Entity::provenance
-     *     [`location`]: Entity::location
-     *     [`confidence`]: Entity::confidence
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
+     *     [`AuditLog::verify`]: crate::entity::audit::AuditLog::verify
+     *     [`kind`]: AuditEvent::kind
+     *     [`parents`]: AuditEvent::parents
+     *     [`hash`]: AuditEvent::hash
+     *     [`confidence`]: AuditEvent::confidence
      */
-    ImageEntity: {
-      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
-      confidence: components["schemas"]["Confidence"];
-      /**
-       * @description Coreference identifier, if a recognizer resolved this entity as one
-       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
-       *     same real-world thing.
-       */
-      coref?: components["schemas"]["EntityCoRef"];
-      /**
-       * Format: uuid
-       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
-       *     when the entity is assembled.
-       */
-      id: string;
+    ImageAuditEvent: {
       /**
-       * @description What kind of sensitive information this is (resolved via a
-       *     [`LabelCatalog`]).
-       */
-      label: components["schemas"]["LabelRef"];
-      /**
-       * @description The language of this entity's surrounding text, when a recognizer
-       *     resolved one. `None` when unknown or language-agnostic.
-       */
-      language?: string;
-      /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      location: components["schemas"]["ImageLocation"];
-      /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
-       */
-      provenance: components["schemas"]["ImageProvenance"];
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description Byte range of the match in the *recognized text* it was found in (the
-       *     OCR layout text, the audio transcript, or the text payload itself) —
-       *     the stable key back into that enrichment artifact, where the rich
-       *     context lives (which OCR block, which speaker) that the geometric
-       *     [`location`] cannot hold. `None` for entities not found via text
-       *     recognition (e.g. a VLM box). Provenance, not a coordinate: redaction
-       *     uses [`location`]; an audit uses this with the artifact.
+       * @description This event's hash, over its payload and its parents' hashes. Assigned by
+       *     [`AuditLog`] when the event is recorded; read it through
+       *     [`hash`](Self::hash). Recomputing it is how the DAG is verified.
        *
-       *     [`location`]: Entity::location
-       */
-      recognized_range?: components["schemas"]["Range_of_uint"];
-    };
-    /**
-     * @description One recognized entity plus the optional reviewer override.
-     *
-     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
-     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
-     *     derivation needs them schema-able. All four modalities elide
-     *     ships satisfy these under the `serde` + `schema` features.
-     */
-    ImageEntityRecord: {
-      /** @description The elide entity, as recognition produced it. */
-      entity: components["schemas"]["ImageEntity"];
-      /**
-       * @description Reviewer-supplied redaction override.
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
        *
-       *     `None` means "use the matching policy rule's decision";
-       *     `Some(...)` overrides that rule for this specific entity
-       *     at apply time. Reviewer overrides take precedence over
-       *     every policy rule and inherit the authority of the
-       *     [`Review::policy_id`] they name — the audit event's
-       *     attribution stamps that policy so the trail names the
-       *     authority under which the override fired.
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      review?: components["schemas"]["Review"];
-    };
-    /**
-     * @description One thing that happened to an entity, with its effect on confidence.
-     *
-     *     Events are recorded in order on an entity's [`Provenance`], forming
-     *     the full audit trail of its life: each recognizer that found it, the
-     *     deduplication that fused them, any score calibration, and the
-     *     redaction that hid it. The uniform spine (who, before/after score,
-     *     when, why) is the same for every event; the [`kind`] carries the
-     *     event-specific detail.
-     *
-     *     `entity.confidence` always equals the [`after`] of the most recent
-     *     event.
-     *
-     *     [`Provenance`]: crate::entity::provenance::Provenance
-     *     [`kind`]: Event::kind
-     *     [`after`]: Event::after
-     */
-    ImageEvent: {
-      /** @description Confidence after this event. */
-      after: components["schemas"]["Confidence"];
-      /** @description When the event happened (UTC). */
-      at: string;
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["ImageAuditKind"];
       /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
+       * @description The events this one follows, by their hash. Empty for a birth event, one
+       *     entry for a normal step, several for a fusion. Assigned by [`AuditLog`]
+       *     when the event is recorded; read it through [`parents`](Self::parents).
+       *
+       *     Not publicly settable: the links are the tamper-evident structure, so
+       *     only [`AuditLog::record`] / [`AuditLog::record_fusion`] assign them.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
+       *     [`AuditLog::record`]: crate::entity::audit::AuditLog::record
+       *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
        */
-      before?: components["schemas"]["Confidence"];
-      /** @description Kind of event, with its event-specific detail. */
-      kind: components["schemas"]["ImageEventKind"];
-      /** @description Free-text explanation of what the event did and why. */
-      reason: string;
+      parents: components["schemas"]["AuditHash"][];
       /**
        * @description Who produced this event: a recognizer name, a deduplication strategy,
        *     an operator, or whatever acted.
        */
       source: string;
+      /** @description When the event happened (UTC). */
+      timestamp: string;
     };
     /**
-     * @description Kind of an [`Event`], carrying its event-specific detail.
+     * @description Kind of an [`AuditEvent`], carrying its event-specific detail and the
+     *     rationale for why it happened.
      *
      *     `#[non_exhaustive]`: new event kinds (verification, annotation, …)
      *     can be added compatibly. The recognition kinds ([`Pattern`],
      *     [`Model`]) carry the matched [`Location`]; the rest carry their own
      *     data.
      *
-     *     [`Pattern`]: EventKind::Pattern
-     *     [`Model`]: EventKind::Model
+     *     [`Pattern`]: AuditKind::Pattern
+     *     [`Model`]: AuditKind::Model
      *     [`Location`]: Modality::Location
      */
-    ImageEventKind: {
+    ImageAuditKind: {
       /** @constant */
       kind: "pattern";
       /** @description Where the recognizer matched. */
@@ -9668,7 +9774,7 @@ interface components {
        *     it is the keyword resolved through the modality's [`locate`] (a
        *     pixel box for image, a time span for audio, the byte range for
        *     text/tabular). `None` when the keyword's stream range could not be
-       *     placed — symmetric with a match the recognizer itself drops.
+       *     placed, symmetric with a match the recognizer itself drops.
        *
        *     [`locate`]: crate::modality::TextRecognizable::locate
        */
@@ -9686,12 +9792,174 @@ interface components {
       /** @description How much the output leaks about the original. */
       leak_profile: components["schemas"]["LeakProfile"];
       /**
-       * @description Which selection rule chose this operator — the automatic "why"
+       * @description Which selection rule chose this operator: the automatic "why"
        *     (matched a label, a tag, a predicate, or the fallback).
        */
       matched_by: components["schemas"]["RuleMatch"];
       /** @description Which operator (name + version) ran. */
       operator: components["schemas"]["OperatorId"];
+      /**
+       * @description BLAKE3 digest of the original text the operator hid, when the
+       *     redaction layer recorded it. Proves *what* was redacted without
+       *     storing the plaintext; `None` when the operator did not capture it.
+       */
+      span_hash?: components["schemas"]["AuditHash"];
+      /**
+       * Format: uint32
+       * @description Byte length of the original text the operator hid, paired with
+       *     [`span_hash`](Self::Redaction::span_hash). `None` when not captured.
+       */
+      span_length?: number;
+    };
+    /**
+     * @description Full audit trail of an [`Entity`]: every [`AuditEvent`] in its life, as a
+     *     tamper-evident DAG.
+     *
+     *     Where Presidio keeps a shallow, optional, per-stage explanation that is
+     *     stripped by default, an `AuditLog` is always present and records the
+     *     entity's *entire* life: each recognizer that found it, the deduplication
+     *     that fused them, any confidence calibration, and the redaction that hid it.
+     *     Nothing is collapsed: every recognizer keeps its own recognition event with
+     *     its location and score.
+     *
+     *     The events form a **directed acyclic graph**, not a flat list. A recognizer
+     *     records a birth event (no parents); each later step links to the event it
+     *     follows; and a [fusion](Self::record_fusion) links to *several* parents at
+     *     once: the heads of the trails it combines. This is the true shape of a
+     *     deduplicated entity: two recognizers are siblings, then a fusion joins them.
+     *     The events are stored in the order they were recorded, which is a
+     *     topological order of the DAG (a parent is always recorded before its
+     *     children).
+     *
+     *     Two chains ride the DAG's edges:
+     *
+     *     - a **confidence chain**, where each event's [`confidence`] is the entity's
+     *       effective score after it; the score flowing *in* is its parents'
+     *       confidence, so [`final_confidence`] and the full history are recoverable;
+     *     - a **hash chain**, where each event's [`hash`] folds its payload together
+     *       with its parents' hashes, so any edit, reorder, insertion, or deletion of
+     *       an earlier event breaks every event downstream. [`verify`] walks the DAG
+     *       and reports the first break.
+     *
+     *     [`Entity`]: crate::entity::Entity
+     *     [`confidence`]: AuditEvent::confidence
+     *     [`hash`]: AuditEvent::hash
+     *     [`final_confidence`]: Self::final_confidence
+     *     [`verify`]: Self::verify
+     */
+    ImageAuditLog: components["schemas"]["ImageAuditEvent"][];
+    /**
+     * @description Per-call payload a recognizer inspects for the [`Image`] modality.
+     *
+     *     Carries the encoded bytes plus the pixel [`Dimensions`], which a
+     *     recognizer that emits unit-square boxes needs to scale them into pixel
+     *     coordinates. An optional filename aids diagnostics and encoding
+     *     inference.
+     *
+     *     [`Image`]: super::Image
+     */
+    ImageData: {
+      /** @description Pixel dimensions of the encoded image. */
+      dimensions: components["schemas"]["Dimensions"];
+      /** @description Original filename, when known. */
+      filename?: string;
+    };
+    /**
+     * @description Detected piece of sensitive information within some medium.
+     *
+     *     Generic over the [`Modality`] `M`, which is what makes the model
+     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
+     *     `Entity<Audio>`, and so on. The entity's location is the modality's
+     *     [`Location`] type, `M::Location`.
+     *
+     *     # Birth and fusion
+     *
+     *     A recognizer emits an entity directly, carrying a single recognition
+     *     [`AuditEvent`] (its own finding) in the entity's [`audit`] trail. When
+     *     several recognizers find the same thing, a fusion step (in
+     *     `elide`) combines their entities into one: the survivor's
+     *     [`location`] and [`confidence`] are the *fused* values, and every
+     *     contributing recognition event, plus a deduplication event, is
+     *     retained in its audit trail. The entity therefore carries its full
+     *     audit trail with it.
+     *
+     *     [`Location`]: Modality::Location
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     *     [`audit`]: Entity::audit
+     *     [`location`]: Entity::location
+     *     [`confidence`]: Entity::confidence
+     */
+    ImageEntity: {
+      /**
+       * @description Tamper-evident audit trail: every contributing detection, the fusion
+       *     event if any, and the redaction that hid it, as a hash-linked DAG.
+       */
+      audit: components["schemas"]["ImageAuditLog"];
+      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
+      confidence: components["schemas"]["Confidence"];
+      /**
+       * @description Coreference identifier, if a recognizer resolved this entity as one
+       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
+       *     same real-world thing.
+       */
+      coref?: components["schemas"]["EntityCoRef"];
+      /**
+       * Format: uuid
+       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
+       *     when the entity is assembled.
+       */
+      id: string;
+      /**
+       * @description What kind of sensitive information this is (resolved via a
+       *     [`LabelCatalog`]).
+       */
+      label: components["schemas"]["LabelRef"];
+      /**
+       * @description The language of this entity's surrounding text, when a recognizer
+       *     resolved one. `None` when unknown or language-agnostic.
+       */
+      language?: string;
+      /**
+       * @description Location of the entity within the medium (fused, if it came from more
+       *     than one detection).
+       */
+      location: components["schemas"]["ImageLocation"];
+      /**
+       * @description Byte range of the match in the *recognized text* it was found in (the
+       *     OCR layout text, the audio transcript, or the text payload itself) —
+       *     the stable key back into that enrichment artifact, where the rich
+       *     context lives (which OCR block, which speaker) that the geometric
+       *     [`location`] cannot hold. `None` for entities not found via text
+       *     recognition (e.g. a VLM box). An audit key, not a coordinate: redaction
+       *     uses [`location`]; an audit uses this with the artifact.
+       *
+       *     [`location`]: Entity::location
+       */
+      recognized_range?: components["schemas"]["Range_of_uint"];
+    };
+    /**
+     * @description One recognized entity plus the optional reviewer override.
+     *
+     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
+     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
+     *     derivation needs them schema-able. All four modalities elide
+     *     ships satisfy these under the `serde` + `schema` features.
+     */
+    ImageEntityRecord: {
+      /** @description The elide entity, as recognition produced it. */
+      entity: components["schemas"]["ImageEntity"];
+      /**
+       * @description Reviewer-supplied redaction override.
+       *
+       *     `None` means "use the matching policy rule's decision";
+       *     `Some(...)` overrides that rule for this specific entity
+       *     at apply time. Reviewer overrides take precedence over
+       *     every policy rule and inherit the authority of the
+       *     [`Review::policy_id`] they name — the audit event's
+       *     attribution stamps that policy so the trail names the
+       *     authority under which the override fired.
+       */
+      review?: components["schemas"]["Review"];
     };
     /**
      * @description Located, typed piece of context a recognizer may treat as in-context
@@ -9738,31 +10006,6 @@ interface components {
        */
       polygon?: components["schemas"]["Polygon"];
     };
-    /**
-     * @description Full audit trail of an [`Entity`]: every [`Event`] in its life, in
-     *     order.
-     *
-     *     This is the model's answer to "full provenance": where Presidio keeps
-     *     a shallow, optional, per-stage explanation that is stripped by
-     *     default, a `Provenance` is always present and records the entity's
-     *     *entire* life as an ordered list of events: each recognizer that
-     *     found it, the deduplication that fused them, any confidence
-     *     calibration, and the redaction that hid it. Nothing is collapsed:
-     *     every recognizer keeps its own recognition event with its location
-     *     and score.
-     *
-     *     The events form a confidence chain (each event's [`after`] is the
-     *     next's [`before`]) so the final confidence and its full history are
-     *     always recoverable.
-     *
-     *     [`Entity`]: crate::entity::Entity
-     *     [`after`]: Event::after
-     *     [`before`]: Event::before
-     */
-    ImageProvenance: {
-      /** @description Events, in the order they happened. */
-      events: components["schemas"]["ImageEvent"][];
-    };
     /** @description Operator spec a `redact` image rule carries. */
     ImageRedaction: {
       /** @constant */
@@ -9947,7 +10190,7 @@ interface components {
     InviteStatus: "pending" | "accepted" | "declined" | "canceled" | "expired" | "revoked";
     /**
      * @description Kind of sensitive information: a stable [`id`], per-language
-     *     [`LabelLocale`]s, and zero or more tags.
+     *     [`LabelLocale`]s, an optional [`category`], and zero or more tags.
      *
      *     # Identity
      *
@@ -9965,18 +10208,25 @@ interface components {
      *     text — NER and LLM read the analysis language's name and description to
      *     prompt the model, keyed by the stable id.
      *
-     *     # Tags
+     *     # Category and tags
+     *
+     *     [`category`] is the single coarse group a label belongs to (`financial`,
+     *     `health`, `identity`, …), for organizing detected entities by kind. Built-in
+     *     labels ship with one; a custom label has none unless set.
      *
-     *     [`tags`] is a free-form list of short identifiers policy selectors can
-     *     match against. Built-in labels carry category tags (`personal_identity`,
-     *     `contact_info`, `financial`, …) plus cross-cutting tags where applicable
-     *     (`pii`, `phi`, `pci`). Custom labels can ship with zero tags.
+     *     [`tags`] is a free-form list of *cross-cutting* markers a policy selector
+     *     matches against — sensitivity flags a label may carry several of (`pii`,
+     *     `phi`, `pci`, `sad`, `secret`). Distinct from the category: a label has at
+     *     most one category but any number of tags. Custom labels can ship with zero
+     *     of either.
      *
      *     [`id`]: Label::id
      *     [`localization`]: Label::localization
+     *     [`category`]: Label::category
      *     [`tags`]: Label::tags
      */
     Label: {
+      category?: components["schemas"]["Category"];
       id: string;
       localizations: components["schemas"]["LocalizedText"];
       tags: string[];
@@ -11032,7 +11282,7 @@ interface components {
        *     [`Attribution::name`] so reviewers can find this policy
        *     from any redaction it drove.
        *
-       *     [`Attribution::name`]: elide_core::entity::provenance::Attribution::name
+       *     [`Attribution::name`]: elide_core::entity::audit::Attribution::name
        */
       id: string;
       /**
@@ -11080,7 +11330,7 @@ interface components {
        *     reviewers can trace which rule fired. Every attachment a
        *     [`RuleDispatch::Table`] expands into shares this UUID.
        *
-       *     [`Attribution::description`]: elide_core::entity::provenance::Attribution::description
+       *     [`Attribution::description`]: elide_core::entity::audit::Attribution::description
        */
       id: string;
       /** @description Human-readable name. Display-only. */
@@ -11172,23 +11422,13 @@ interface components {
      *     operator options,
      *     `{"kind": "pci_dss_pan", "render": "hmac_sha256"}`.
      */
-    PolicyTemplate: {
+    PolicyTemplate: ({
       /** @constant */
       kind: "hipaa_deidentification";
-      /**
-       * @description Which §164.514 method to apply. See [`HipaaDeidMethod`]
-       *     for the tradeoff.
-       */
-      method: components["schemas"]["HipaaDeidMethod"];
-    } | {
+    } & components["schemas"]["HipaaDeidentification"]) | ({
       /** @constant */
       kind: "gdpr_article9";
-      /**
-       * @description Which operator to apply to Article 9 matches. See
-       *     [`GdprArticle9Treatment`] for the tradeoff.
-       */
-      treatment: components["schemas"]["GdprArticle9Treatment"];
-    } | {
+    } & components["schemas"]["GdprArticle9"]) | {
       /** @constant */
       kind: "pci_dss";
       /**
@@ -11199,6 +11439,9 @@ interface components {
     } | {
       /** @constant */
       kind: "ccpa";
+    } | {
+      /** @constant */
+      kind: "soc2_secrets";
     };
     /**
      * @description Closed polygon, given by its ordered vertices.
@@ -11439,7 +11682,7 @@ interface components {
      *     closure into provenance, so [`Predicate`] records only that a predicate
      *     matched, not which one.
      *
-     *     [`Redaction`]: crate::entity::provenance::EventKind::Redaction
+     *     [`Redaction`]: crate::entity::audit::AuditKind::Redaction
      *     [`Predicate`]: RuleMatch::Predicate
      */
     RuleMatch: {
@@ -11781,152 +12024,90 @@ interface components {
       reportId?: string;
     };
     /**
-     * @description Detected piece of sensitive information within some medium.
+     * @description One node in an entity's audit DAG: a thing that happened, with its
+     *     effect on confidence and its tamper-evident links.
      *
-     *     Generic over the [`Modality`] `M`, which is what makes the model
-     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
-     *     `Entity<Audio>`, and so on. The entity's location is the modality's
-     *     [`Location`] type, `M::Location`.
+     *     Events are recorded on an entity's [`AuditLog`], forming the full audit
+     *     trail of its life: each recognizer that found it, the deduplication that
+     *     fused them, any score calibration, and the redaction that hid it. The
+     *     uniform spine (who, resulting score, when) is the same for every event; the
+     *     [`kind`] carries the event-specific detail *and* the explanation of why the
+     *     event happened.
      *
-     *     # Birth and fusion
+     *     Each event links to its [`parents`] by their [`hash`]: a birth event (a
+     *     recognizer's first detection) has no parents, a normal step has one, and a
+     *     [fusion](crate::entity::audit::AuditLog::record_fusion) has several. Its own
+     *     [`hash`] folds the
+     *     payload together with the parents' hashes, so altering any event breaks
+     *     every event downstream of it: [`AuditLog::verify`] walks the DAG and
+     *     reports the first break.
      *
-     *     A recognizer emits an entity directly, carrying a single recognition
-     *     [`Event`] (its own finding) in the entity's [`provenance`]. When
-     *     several recognizers find the same thing, a fusion step (in
-     *     `elide`) combines their entities into one: the survivor's
-     *     [`location`] and [`confidence`] are the *fused* values, and every
-     *     contributing recognition event, plus a deduplication event, is
-     *     retained in its provenance. The entity therefore carries its full
-     *     audit trail with it.
+     *     `entity.confidence` always equals the [`confidence`] of the most recent
+     *     event. The confidence *flowing in* is not stored: it is the parents'
+     *     [`confidence`], recovered from the DAG.
      *
-     *     [`Location`]: Modality::Location
-     *     [`Event`]: crate::entity::provenance::Event
-     *     [`provenance`]: Entity::provenance
-     *     [`location`]: Entity::location
-     *     [`confidence`]: Entity::confidence
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
+     *     [`AuditLog::verify`]: crate::entity::audit::AuditLog::verify
+     *     [`kind`]: AuditEvent::kind
+     *     [`parents`]: AuditEvent::parents
+     *     [`hash`]: AuditEvent::hash
+     *     [`confidence`]: AuditEvent::confidence
      */
-    TabularEntity: {
-      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
-      confidence: components["schemas"]["Confidence"];
-      /**
-       * @description Coreference identifier, if a recognizer resolved this entity as one
-       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
-       *     same real-world thing.
-       */
-      coref?: components["schemas"]["EntityCoRef"];
+    TabularAuditEvent: {
       /**
-       * Format: uuid
-       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
-       *     when the entity is assembled.
-       */
-      id: string;
-      /**
-       * @description What kind of sensitive information this is (resolved via a
-       *     [`LabelCatalog`]).
-       */
-      label: components["schemas"]["LabelRef"];
-      /**
-       * @description The language of this entity's surrounding text, when a recognizer
-       *     resolved one. `None` when unknown or language-agnostic.
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      language?: string;
-      /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
-       */
-      location: components["schemas"]["TabularLocation"];
-      /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
-       */
-      provenance: components["schemas"]["TabularProvenance"];
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description Byte range of the match in the *recognized text* it was found in (the
-       *     OCR layout text, the audio transcript, or the text payload itself) —
-       *     the stable key back into that enrichment artifact, where the rich
-       *     context lives (which OCR block, which speaker) that the geometric
-       *     [`location`] cannot hold. `None` for entities not found via text
-       *     recognition (e.g. a VLM box). Provenance, not a coordinate: redaction
-       *     uses [`location`]; an audit uses this with the artifact.
+       * @description This event's hash, over its payload and its parents' hashes. Assigned by
+       *     [`AuditLog`] when the event is recorded; read it through
+       *     [`hash`](Self::hash). Recomputing it is how the DAG is verified.
        *
-       *     [`location`]: Entity::location
-       */
-      recognized_range?: components["schemas"]["Range_of_uint"];
-    };
-    /**
-     * @description One recognized entity plus the optional reviewer override.
-     *
-     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
-     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
-     *     derivation needs them schema-able. All four modalities elide
-     *     ships satisfy these under the `serde` + `schema` features.
-     */
-    TabularEntityRecord: {
-      /** @description The elide entity, as recognition produced it. */
-      entity: components["schemas"]["TabularEntity"];
-      /**
-       * @description Reviewer-supplied redaction override.
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
        *
-       *     `None` means "use the matching policy rule's decision";
-       *     `Some(...)` overrides that rule for this specific entity
-       *     at apply time. Reviewer overrides take precedence over
-       *     every policy rule and inherit the authority of the
-       *     [`Review::policy_id`] they name — the audit event's
-       *     attribution stamps that policy so the trail names the
-       *     authority under which the override fired.
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      review?: components["schemas"]["Review"];
-    };
-    /**
-     * @description One thing that happened to an entity, with its effect on confidence.
-     *
-     *     Events are recorded in order on an entity's [`Provenance`], forming
-     *     the full audit trail of its life: each recognizer that found it, the
-     *     deduplication that fused them, any score calibration, and the
-     *     redaction that hid it. The uniform spine (who, before/after score,
-     *     when, why) is the same for every event; the [`kind`] carries the
-     *     event-specific detail.
-     *
-     *     `entity.confidence` always equals the [`after`] of the most recent
-     *     event.
-     *
-     *     [`Provenance`]: crate::entity::provenance::Provenance
-     *     [`kind`]: Event::kind
-     *     [`after`]: Event::after
-     */
-    TabularEvent: {
-      /** @description Confidence after this event. */
-      after: components["schemas"]["Confidence"];
-      /** @description When the event happened (UTC). */
-      at: string;
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["TabularAuditKind"];
       /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
+       * @description The events this one follows, by their hash. Empty for a birth event, one
+       *     entry for a normal step, several for a fusion. Assigned by [`AuditLog`]
+       *     when the event is recorded; read it through [`parents`](Self::parents).
+       *
+       *     Not publicly settable: the links are the tamper-evident structure, so
+       *     only [`AuditLog::record`] / [`AuditLog::record_fusion`] assign them.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
+       *     [`AuditLog::record`]: crate::entity::audit::AuditLog::record
+       *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
        */
-      before?: components["schemas"]["Confidence"];
-      /** @description Kind of event, with its event-specific detail. */
-      kind: components["schemas"]["TabularEventKind"];
-      /** @description Free-text explanation of what the event did and why. */
-      reason: string;
+      parents: components["schemas"]["AuditHash"][];
       /**
        * @description Who produced this event: a recognizer name, a deduplication strategy,
        *     an operator, or whatever acted.
        */
       source: string;
+      /** @description When the event happened (UTC). */
+      timestamp: string;
     };
     /**
-     * @description Kind of an [`Event`], carrying its event-specific detail.
+     * @description Kind of an [`AuditEvent`], carrying its event-specific detail and the
+     *     rationale for why it happened.
      *
      *     `#[non_exhaustive]`: new event kinds (verification, annotation, …)
      *     can be added compatibly. The recognition kinds ([`Pattern`],
      *     [`Model`]) carry the matched [`Location`]; the rest carry their own
      *     data.
      *
-     *     [`Pattern`]: EventKind::Pattern
-     *     [`Model`]: EventKind::Model
+     *     [`Pattern`]: AuditKind::Pattern
+     *     [`Model`]: AuditKind::Model
      *     [`Location`]: Modality::Location
      */
-    TabularEventKind: {
+    TabularAuditKind: {
       /** @constant */
       kind: "pattern";
       /** @description Where the recognizer matched. */
@@ -11990,7 +12171,7 @@ interface components {
        *     it is the keyword resolved through the modality's [`locate`] (a
        *     pixel box for image, a time span for audio, the byte range for
        *     text/tabular). `None` when the keyword's stream range could not be
-       *     placed — symmetric with a match the recognizer itself drops.
+       *     placed, symmetric with a match the recognizer itself drops.
        *
        *     [`locate`]: crate::modality::TextRecognizable::locate
        */
@@ -12008,12 +12189,158 @@ interface components {
       /** @description How much the output leaks about the original. */
       leak_profile: components["schemas"]["LeakProfile"];
       /**
-       * @description Which selection rule chose this operator — the automatic "why"
+       * @description Which selection rule chose this operator: the automatic "why"
        *     (matched a label, a tag, a predicate, or the fallback).
        */
       matched_by: components["schemas"]["RuleMatch"];
       /** @description Which operator (name + version) ran. */
       operator: components["schemas"]["OperatorId"];
+      /**
+       * @description BLAKE3 digest of the original text the operator hid, when the
+       *     redaction layer recorded it. Proves *what* was redacted without
+       *     storing the plaintext; `None` when the operator did not capture it.
+       */
+      span_hash?: components["schemas"]["AuditHash"];
+      /**
+       * Format: uint32
+       * @description Byte length of the original text the operator hid, paired with
+       *     [`span_hash`](Self::Redaction::span_hash). `None` when not captured.
+       */
+      span_length?: number;
+    };
+    /**
+     * @description Full audit trail of an [`Entity`]: every [`AuditEvent`] in its life, as a
+     *     tamper-evident DAG.
+     *
+     *     Where Presidio keeps a shallow, optional, per-stage explanation that is
+     *     stripped by default, an `AuditLog` is always present and records the
+     *     entity's *entire* life: each recognizer that found it, the deduplication
+     *     that fused them, any confidence calibration, and the redaction that hid it.
+     *     Nothing is collapsed: every recognizer keeps its own recognition event with
+     *     its location and score.
+     *
+     *     The events form a **directed acyclic graph**, not a flat list. A recognizer
+     *     records a birth event (no parents); each later step links to the event it
+     *     follows; and a [fusion](Self::record_fusion) links to *several* parents at
+     *     once: the heads of the trails it combines. This is the true shape of a
+     *     deduplicated entity: two recognizers are siblings, then a fusion joins them.
+     *     The events are stored in the order they were recorded, which is a
+     *     topological order of the DAG (a parent is always recorded before its
+     *     children).
+     *
+     *     Two chains ride the DAG's edges:
+     *
+     *     - a **confidence chain**, where each event's [`confidence`] is the entity's
+     *       effective score after it; the score flowing *in* is its parents'
+     *       confidence, so [`final_confidence`] and the full history are recoverable;
+     *     - a **hash chain**, where each event's [`hash`] folds its payload together
+     *       with its parents' hashes, so any edit, reorder, insertion, or deletion of
+     *       an earlier event breaks every event downstream. [`verify`] walks the DAG
+     *       and reports the first break.
+     *
+     *     [`Entity`]: crate::entity::Entity
+     *     [`confidence`]: AuditEvent::confidence
+     *     [`hash`]: AuditEvent::hash
+     *     [`final_confidence`]: Self::final_confidence
+     *     [`verify`]: Self::verify
+     */
+    TabularAuditLog: components["schemas"]["TabularAuditEvent"][];
+    /**
+     * @description Detected piece of sensitive information within some medium.
+     *
+     *     Generic over the [`Modality`] `M`, which is what makes the model
+     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
+     *     `Entity<Audio>`, and so on. The entity's location is the modality's
+     *     [`Location`] type, `M::Location`.
+     *
+     *     # Birth and fusion
+     *
+     *     A recognizer emits an entity directly, carrying a single recognition
+     *     [`AuditEvent`] (its own finding) in the entity's [`audit`] trail. When
+     *     several recognizers find the same thing, a fusion step (in
+     *     `elide`) combines their entities into one: the survivor's
+     *     [`location`] and [`confidence`] are the *fused* values, and every
+     *     contributing recognition event, plus a deduplication event, is
+     *     retained in its audit trail. The entity therefore carries its full
+     *     audit trail with it.
+     *
+     *     [`Location`]: Modality::Location
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     *     [`audit`]: Entity::audit
+     *     [`location`]: Entity::location
+     *     [`confidence`]: Entity::confidence
+     */
+    TabularEntity: {
+      /**
+       * @description Tamper-evident audit trail: every contributing detection, the fusion
+       *     event if any, and the redaction that hid it, as a hash-linked DAG.
+       */
+      audit: components["schemas"]["TabularAuditLog"];
+      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
+      confidence: components["schemas"]["Confidence"];
+      /**
+       * @description Coreference identifier, if a recognizer resolved this entity as one
+       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
+       *     same real-world thing.
+       */
+      coref?: components["schemas"]["EntityCoRef"];
+      /**
+       * Format: uuid
+       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
+       *     when the entity is assembled.
+       */
+      id: string;
+      /**
+       * @description What kind of sensitive information this is (resolved via a
+       *     [`LabelCatalog`]).
+       */
+      label: components["schemas"]["LabelRef"];
+      /**
+       * @description The language of this entity's surrounding text, when a recognizer
+       *     resolved one. `None` when unknown or language-agnostic.
+       */
+      language?: string;
+      /**
+       * @description Location of the entity within the medium (fused, if it came from more
+       *     than one detection).
+       */
+      location: components["schemas"]["TabularLocation"];
+      /**
+       * @description Byte range of the match in the *recognized text* it was found in (the
+       *     OCR layout text, the audio transcript, or the text payload itself) —
+       *     the stable key back into that enrichment artifact, where the rich
+       *     context lives (which OCR block, which speaker) that the geometric
+       *     [`location`] cannot hold. `None` for entities not found via text
+       *     recognition (e.g. a VLM box). An audit key, not a coordinate: redaction
+       *     uses [`location`]; an audit uses this with the artifact.
+       *
+       *     [`location`]: Entity::location
+       */
+      recognized_range?: components["schemas"]["Range_of_uint"];
+    };
+    /**
+     * @description One recognized entity plus the optional reviewer override.
+     *
+     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
+     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
+     *     derivation needs them schema-able. All four modalities elide
+     *     ships satisfy these under the `serde` + `schema` features.
+     */
+    TabularEntityRecord: {
+      /** @description The elide entity, as recognition produced it. */
+      entity: components["schemas"]["TabularEntity"];
+      /**
+       * @description Reviewer-supplied redaction override.
+       *
+       *     `None` means "use the matching policy rule's decision";
+       *     `Some(...)` overrides that rule for this specific entity
+       *     at apply time. Reviewer overrides take precedence over
+       *     every policy rule and inherit the authority of the
+       *     [`Review::policy_id`] they name — the audit event's
+       *     attribution stamps that policy so the trail names the
+       *     authority under which the override fired.
+       */
+      review?: components["schemas"]["Review"];
     };
     /**
      * @description Located, typed piece of context a recognizer may treat as in-context
@@ -12085,31 +12412,6 @@ interface components {
        */
       start_offset?: number;
     };
-    /**
-     * @description Full audit trail of an [`Entity`]: every [`Event`] in its life, in
-     *     order.
-     *
-     *     This is the model's answer to "full provenance": where Presidio keeps
-     *     a shallow, optional, per-stage explanation that is stripped by
-     *     default, a `Provenance` is always present and records the entity's
-     *     *entire* life as an ordered list of events: each recognizer that
-     *     found it, the deduplication that fused them, any confidence
-     *     calibration, and the redaction that hid it. Nothing is collapsed:
-     *     every recognizer keeps its own recognition event with its location
-     *     and score.
-     *
-     *     The events form a confidence chain (each event's [`after`] is the
-     *     next's [`before`]) so the final confidence and its full history are
-     *     always recoverable.
-     *
-     *     [`Entity`]: crate::entity::Entity
-     *     [`after`]: Event::after
-     *     [`before`]: Event::before
-     */
-    TabularProvenance: {
-      /** @description Events, in the order they happened. */
-      events: components["schemas"]["TabularEvent"][];
-    };
     /** @description Operator spec a `redact` tabular rule carries. */
     TabularRedaction: {
       /** @constant */
@@ -12187,163 +12489,90 @@ interface components {
       payload?: unknown;
     };
     /**
-     * @description Run of text.
+     * @description One node in an entity's audit DAG: a thing that happened, with its
+     *     effect on confidence and its tamper-evident links.
      *
-     *     Either the payload a text recognizer inspects, or the value sliced out
-     *     at an entity's location for an operator.
+     *     Events are recorded on an entity's [`AuditLog`], forming the full audit
+     *     trail of its life: each recognizer that found it, the deduplication that
+     *     fused them, any score calibration, and the redaction that hid it. The
+     *     uniform spine (who, resulting score, when) is the same for every event; the
+     *     [`kind`] carries the event-specific detail *and* the explanation of why the
+     *     event happened.
      *
-     *     Held as a [`HipStr`] so short values inline and longer ones share a
-     *     refcounted buffer, making cheap clones when one payload is passed to
-     *     several recognizers.
-     */
-    TextData: string;
-    /**
-     * @description Detected piece of sensitive information within some medium.
-     *
-     *     Generic over the [`Modality`] `M`, which is what makes the model
-     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
-     *     `Entity<Audio>`, and so on. The entity's location is the modality's
-     *     [`Location`] type, `M::Location`.
+     *     Each event links to its [`parents`] by their [`hash`]: a birth event (a
+     *     recognizer's first detection) has no parents, a normal step has one, and a
+     *     [fusion](crate::entity::audit::AuditLog::record_fusion) has several. Its own
+     *     [`hash`] folds the
+     *     payload together with the parents' hashes, so altering any event breaks
+     *     every event downstream of it: [`AuditLog::verify`] walks the DAG and
+     *     reports the first break.
      *
-     *     # Birth and fusion
+     *     `entity.confidence` always equals the [`confidence`] of the most recent
+     *     event. The confidence *flowing in* is not stored: it is the parents'
+     *     [`confidence`], recovered from the DAG.
      *
-     *     A recognizer emits an entity directly, carrying a single recognition
-     *     [`Event`] (its own finding) in the entity's [`provenance`]. When
-     *     several recognizers find the same thing, a fusion step (in
-     *     `elide`) combines their entities into one: the survivor's
-     *     [`location`] and [`confidence`] are the *fused* values, and every
-     *     contributing recognition event, plus a deduplication event, is
-     *     retained in its provenance. The entity therefore carries its full
-     *     audit trail with it.
-     *
-     *     [`Location`]: Modality::Location
-     *     [`Event`]: crate::entity::provenance::Event
-     *     [`provenance`]: Entity::provenance
-     *     [`location`]: Entity::location
-     *     [`confidence`]: Entity::confidence
+     *     [`AuditLog`]: crate::entity::audit::AuditLog
+     *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
+     *     [`AuditLog::verify`]: crate::entity::audit::AuditLog::verify
+     *     [`kind`]: AuditEvent::kind
+     *     [`parents`]: AuditEvent::parents
+     *     [`hash`]: AuditEvent::hash
+     *     [`confidence`]: AuditEvent::confidence
      */
-    TextEntity: {
-      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
-      confidence: components["schemas"]["Confidence"];
-      /**
-       * @description Coreference identifier, if a recognizer resolved this entity as one
-       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
-       *     same real-world thing.
-       */
-      coref?: components["schemas"]["EntityCoRef"];
+    TextAuditEvent: {
       /**
-       * Format: uuid
-       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
-       *     when the entity is assembled.
-       */
-      id: string;
-      /**
-       * @description What kind of sensitive information this is (resolved via a
-       *     [`LabelCatalog`]).
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      label: components["schemas"]["LabelRef"];
-      /**
-       * @description The language of this entity's surrounding text, when a recognizer
-       *     resolved one. `None` when unknown or language-agnostic.
-       */
-      language?: string;
-      /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
-       */
-      location: components["schemas"]["TextLocation"];
-      /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
-       */
-      provenance: components["schemas"]["TextProvenance"];
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description Byte range of the match in the *recognized text* it was found in (the
-       *     OCR layout text, the audio transcript, or the text payload itself) —
-       *     the stable key back into that enrichment artifact, where the rich
-       *     context lives (which OCR block, which speaker) that the geometric
-       *     [`location`] cannot hold. `None` for entities not found via text
-       *     recognition (e.g. a VLM box). Provenance, not a coordinate: redaction
-       *     uses [`location`]; an audit uses this with the artifact.
+       * @description This event's hash, over its payload and its parents' hashes. Assigned by
+       *     [`AuditLog`] when the event is recorded; read it through
+       *     [`hash`](Self::hash). Recomputing it is how the DAG is verified.
        *
-       *     [`location`]: Entity::location
-       */
-      recognized_range?: components["schemas"]["Range_of_uint"];
-    };
-    /**
-     * @description One recognized entity plus the optional reviewer override.
-     *
-     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
-     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
-     *     derivation needs them schema-able. All four modalities elide
-     *     ships satisfy these under the `serde` + `schema` features.
-     */
-    TextEntityRecord: {
-      /** @description The elide entity, as recognition produced it. */
-      entity: components["schemas"]["TextEntity"];
-      /**
-       * @description Reviewer-supplied redaction override.
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
        *
-       *     `None` means "use the matching policy rule's decision";
-       *     `Some(...)` overrides that rule for this specific entity
-       *     at apply time. Reviewer overrides take precedence over
-       *     every policy rule and inherit the authority of the
-       *     [`Review::policy_id`] they name — the audit event's
-       *     attribution stamps that policy so the trail names the
-       *     authority under which the override fired.
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      review?: components["schemas"]["Review"];
-    };
-    /**
-     * @description One thing that happened to an entity, with its effect on confidence.
-     *
-     *     Events are recorded in order on an entity's [`Provenance`], forming
-     *     the full audit trail of its life: each recognizer that found it, the
-     *     deduplication that fused them, any score calibration, and the
-     *     redaction that hid it. The uniform spine (who, before/after score,
-     *     when, why) is the same for every event; the [`kind`] carries the
-     *     event-specific detail.
-     *
-     *     `entity.confidence` always equals the [`after`] of the most recent
-     *     event.
-     *
-     *     [`Provenance`]: crate::entity::provenance::Provenance
-     *     [`kind`]: Event::kind
-     *     [`after`]: Event::after
-     */
-    TextEvent: {
-      /** @description Confidence after this event. */
-      after: components["schemas"]["Confidence"];
-      /** @description When the event happened (UTC). */
-      at: string;
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["TextAuditKind"];
       /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
+       * @description The events this one follows, by their hash. Empty for a birth event, one
+       *     entry for a normal step, several for a fusion. Assigned by [`AuditLog`]
+       *     when the event is recorded; read it through [`parents`](Self::parents).
+       *
+       *     Not publicly settable: the links are the tamper-evident structure, so
+       *     only [`AuditLog::record`] / [`AuditLog::record_fusion`] assign them.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
+       *     [`AuditLog::record`]: crate::entity::audit::AuditLog::record
+       *     [`AuditLog::record_fusion`]: crate::entity::audit::AuditLog::record_fusion
        */
-      before?: components["schemas"]["Confidence"];
-      /** @description Kind of event, with its event-specific detail. */
-      kind: components["schemas"]["TextEventKind"];
-      /** @description Free-text explanation of what the event did and why. */
-      reason: string;
+      parents: components["schemas"]["AuditHash"][];
       /**
        * @description Who produced this event: a recognizer name, a deduplication strategy,
        *     an operator, or whatever acted.
        */
       source: string;
+      /** @description When the event happened (UTC). */
+      timestamp: string;
     };
     /**
-     * @description Kind of an [`Event`], carrying its event-specific detail.
+     * @description Kind of an [`AuditEvent`], carrying its event-specific detail and the
+     *     rationale for why it happened.
      *
      *     `#[non_exhaustive]`: new event kinds (verification, annotation, …)
      *     can be added compatibly. The recognition kinds ([`Pattern`],
      *     [`Model`]) carry the matched [`Location`]; the rest carry their own
      *     data.
      *
-     *     [`Pattern`]: EventKind::Pattern
-     *     [`Model`]: EventKind::Model
+     *     [`Pattern`]: AuditKind::Pattern
+     *     [`Model`]: AuditKind::Model
      *     [`Location`]: Modality::Location
      */
-    TextEventKind: {
+    TextAuditKind: {
       /** @constant */
       kind: "pattern";
       /** @description Where the recognizer matched. */
@@ -12407,7 +12636,7 @@ interface components {
        *     it is the keyword resolved through the modality's [`locate`] (a
        *     pixel box for image, a time span for audio, the byte range for
        *     text/tabular). `None` when the keyword's stream range could not be
-       *     placed — symmetric with a match the recognizer itself drops.
+       *     placed, symmetric with a match the recognizer itself drops.
        *
        *     [`locate`]: crate::modality::TextRecognizable::locate
        */
@@ -12425,12 +12654,169 @@ interface components {
       /** @description How much the output leaks about the original. */
       leak_profile: components["schemas"]["LeakProfile"];
       /**
-       * @description Which selection rule chose this operator — the automatic "why"
+       * @description Which selection rule chose this operator: the automatic "why"
        *     (matched a label, a tag, a predicate, or the fallback).
        */
       matched_by: components["schemas"]["RuleMatch"];
       /** @description Which operator (name + version) ran. */
       operator: components["schemas"]["OperatorId"];
+      /**
+       * @description BLAKE3 digest of the original text the operator hid, when the
+       *     redaction layer recorded it. Proves *what* was redacted without
+       *     storing the plaintext; `None` when the operator did not capture it.
+       */
+      span_hash?: components["schemas"]["AuditHash"];
+      /**
+       * Format: uint32
+       * @description Byte length of the original text the operator hid, paired with
+       *     [`span_hash`](Self::Redaction::span_hash). `None` when not captured.
+       */
+      span_length?: number;
+    };
+    /**
+     * @description Full audit trail of an [`Entity`]: every [`AuditEvent`] in its life, as a
+     *     tamper-evident DAG.
+     *
+     *     Where Presidio keeps a shallow, optional, per-stage explanation that is
+     *     stripped by default, an `AuditLog` is always present and records the
+     *     entity's *entire* life: each recognizer that found it, the deduplication
+     *     that fused them, any confidence calibration, and the redaction that hid it.
+     *     Nothing is collapsed: every recognizer keeps its own recognition event with
+     *     its location and score.
+     *
+     *     The events form a **directed acyclic graph**, not a flat list. A recognizer
+     *     records a birth event (no parents); each later step links to the event it
+     *     follows; and a [fusion](Self::record_fusion) links to *several* parents at
+     *     once: the heads of the trails it combines. This is the true shape of a
+     *     deduplicated entity: two recognizers are siblings, then a fusion joins them.
+     *     The events are stored in the order they were recorded, which is a
+     *     topological order of the DAG (a parent is always recorded before its
+     *     children).
+     *
+     *     Two chains ride the DAG's edges:
+     *
+     *     - a **confidence chain**, where each event's [`confidence`] is the entity's
+     *       effective score after it; the score flowing *in* is its parents'
+     *       confidence, so [`final_confidence`] and the full history are recoverable;
+     *     - a **hash chain**, where each event's [`hash`] folds its payload together
+     *       with its parents' hashes, so any edit, reorder, insertion, or deletion of
+     *       an earlier event breaks every event downstream. [`verify`] walks the DAG
+     *       and reports the first break.
+     *
+     *     [`Entity`]: crate::entity::Entity
+     *     [`confidence`]: AuditEvent::confidence
+     *     [`hash`]: AuditEvent::hash
+     *     [`final_confidence`]: Self::final_confidence
+     *     [`verify`]: Self::verify
+     */
+    TextAuditLog: components["schemas"]["TextAuditEvent"][];
+    /**
+     * @description Run of text.
+     *
+     *     Either the payload a text recognizer inspects, or the value sliced out
+     *     at an entity's location for an operator.
+     *
+     *     Held as a [`HipStr`] so short values inline and longer ones share a
+     *     refcounted buffer, making cheap clones when one payload is passed to
+     *     several recognizers.
+     */
+    TextData: string;
+    /**
+     * @description Detected piece of sensitive information within some medium.
+     *
+     *     Generic over the [`Modality`] `M`, which is what makes the model
+     *     multimodal: a text pipeline yields `Entity<Text>`, an audio pipeline
+     *     `Entity<Audio>`, and so on. The entity's location is the modality's
+     *     [`Location`] type, `M::Location`.
+     *
+     *     # Birth and fusion
+     *
+     *     A recognizer emits an entity directly, carrying a single recognition
+     *     [`AuditEvent`] (its own finding) in the entity's [`audit`] trail. When
+     *     several recognizers find the same thing, a fusion step (in
+     *     `elide`) combines their entities into one: the survivor's
+     *     [`location`] and [`confidence`] are the *fused* values, and every
+     *     contributing recognition event, plus a deduplication event, is
+     *     retained in its audit trail. The entity therefore carries its full
+     *     audit trail with it.
+     *
+     *     [`Location`]: Modality::Location
+     *     [`AuditEvent`]: crate::entity::audit::AuditEvent
+     *     [`audit`]: Entity::audit
+     *     [`location`]: Entity::location
+     *     [`confidence`]: Entity::confidence
+     */
+    TextEntity: {
+      /**
+       * @description Tamper-evident audit trail: every contributing detection, the fusion
+       *     event if any, and the redaction that hid it, as a hash-linked DAG.
+       */
+      audit: components["schemas"]["TextAuditLog"];
+      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
+      confidence: components["schemas"]["Confidence"];
+      /**
+       * @description Coreference identifier, if a recognizer resolved this entity as one
+       *     mention of a cluster. Entities sharing an [`EntityCoRef`] denote the
+       *     same real-world thing.
+       */
+      coref?: components["schemas"]["EntityCoRef"];
+      /**
+       * Format: uuid
+       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
+       *     when the entity is assembled.
+       */
+      id: string;
+      /**
+       * @description What kind of sensitive information this is (resolved via a
+       *     [`LabelCatalog`]).
+       */
+      label: components["schemas"]["LabelRef"];
+      /**
+       * @description The language of this entity's surrounding text, when a recognizer
+       *     resolved one. `None` when unknown or language-agnostic.
+       */
+      language?: string;
+      /**
+       * @description Location of the entity within the medium (fused, if it came from more
+       *     than one detection).
+       */
+      location: components["schemas"]["TextLocation"];
+      /**
+       * @description Byte range of the match in the *recognized text* it was found in (the
+       *     OCR layout text, the audio transcript, or the text payload itself) —
+       *     the stable key back into that enrichment artifact, where the rich
+       *     context lives (which OCR block, which speaker) that the geometric
+       *     [`location`] cannot hold. `None` for entities not found via text
+       *     recognition (e.g. a VLM box). An audit key, not a coordinate: redaction
+       *     uses [`location`]; an audit uses this with the artifact.
+       *
+       *     [`location`]: Entity::location
+       */
+      recognized_range?: components["schemas"]["Range_of_uint"];
+    };
+    /**
+     * @description One recognized entity plus the optional reviewer override.
+     *
+     *     The bound mirrors elide's [`Entity<M>`]: serialization needs
+     *     `M::Location` and `M::Data` (de)serializable, and JsonSchema
+     *     derivation needs them schema-able. All four modalities elide
+     *     ships satisfy these under the `serde` + `schema` features.
+     */
+    TextEntityRecord: {
+      /** @description The elide entity, as recognition produced it. */
+      entity: components["schemas"]["TextEntity"];
+      /**
+       * @description Reviewer-supplied redaction override.
+       *
+       *     `None` means "use the matching policy rule's decision";
+       *     `Some(...)` overrides that rule for this specific entity
+       *     at apply time. Reviewer overrides take precedence over
+       *     every policy rule and inherit the authority of the
+       *     [`Review::policy_id`] they name — the audit event's
+       *     attribution stamps that policy so the trail names the
+       *     authority under which the override fired.
+       */
+      review?: components["schemas"]["Review"];
     };
     /**
      * @description Located, typed piece of context a recognizer may treat as in-context
@@ -12479,31 +12865,6 @@ interface components {
        */
       start: number;
     };
-    /**
-     * @description Full audit trail of an [`Entity`]: every [`Event`] in its life, in
-     *     order.
-     *
-     *     This is the model's answer to "full provenance": where Presidio keeps
-     *     a shallow, optional, per-stage explanation that is stripped by
-     *     default, a `Provenance` is always present and records the entity's
-     *     *entire* life as an ordered list of events: each recognizer that
-     *     found it, the deduplication that fused them, any confidence
-     *     calibration, and the redaction that hid it. Nothing is collapsed:
-     *     every recognizer keeps its own recognition event with its location
-     *     and score.
-     *
-     *     The events form a confidence chain (each event's [`after`] is the
-     *     next's [`before`]) so the final confidence and its full history are
-     *     always recoverable.
-     *
-     *     [`Entity`]: crate::entity::Entity
-     *     [`after`]: Event::after
-     *     [`before`]: Event::before
-     */
-    TextProvenance: {
-      /** @description Events, in the order they happened. */
-      events: components["schemas"]["TextEvent"][];
-    };
     /** @description Operator spec a `redact` text rule carries. */
     TextRedaction: {
       /** @constant */
@@ -13229,6 +13590,8 @@ type RuleMatch = Schemas$16["RuleMatch"];
 type ModelEvent = Schemas$16["ModelEvent"];
 type PatternEvent = Schemas$16["PatternEvent"];
 type OperatorId = Schemas$16["OperatorId"];
+type AuditHash = Schemas$16["AuditHash"];
+type Category = Schemas$16["Category"];
 /** Half-open `[start, end)` index range. Generated name; a plain uint range. */
 type RangeOfUint = Schemas$16["Range_of_uint"];
 type BoundingBox = Schemas$16["BoundingBox"];
@@ -13238,35 +13601,35 @@ type Dimensions = Schemas$16["Dimensions"];
 type TimeSpan = Schemas$16["TimeSpan"];
 type TextEntity = Schemas$16["TextEntity"];
 type TextEntityRecord = Schemas$16["TextEntityRecord"];
-type TextEvent = Schemas$16["TextEvent"];
-type TextEventKind = Schemas$16["TextEventKind"];
+type TextAuditEvent = Schemas$16["TextAuditEvent"];
+type TextAuditKind = Schemas$16["TextAuditKind"];
 type TextHint = Schemas$16["TextHint"];
 type TextLocation = Schemas$16["TextLocation"];
-type TextProvenance = Schemas$16["TextProvenance"];
+type TextAuditLog = Schemas$16["TextAuditLog"];
 type TextData = Schemas$16["TextData"];
 type ImageEntity = Schemas$16["ImageEntity"];
 type ImageEntityRecord = Schemas$16["ImageEntityRecord"];
-type ImageEvent = Schemas$16["ImageEvent"];
-type ImageEventKind = Schemas$16["ImageEventKind"];
+type ImageAuditEvent = Schemas$16["ImageAuditEvent"];
+type ImageAuditKind = Schemas$16["ImageAuditKind"];
 type ImageHint = Schemas$16["ImageHint"];
 type ImageLocation = Schemas$16["ImageLocation"];
-type ImageProvenance = Schemas$16["ImageProvenance"];
+type ImageAuditLog = Schemas$16["ImageAuditLog"];
 type ImageData = Schemas$16["ImageData"];
 type AudioEntity = Schemas$16["AudioEntity"];
 type AudioEntityRecord = Schemas$16["AudioEntityRecord"];
-type AudioEvent = Schemas$16["AudioEvent"];
-type AudioEventKind = Schemas$16["AudioEventKind"];
+type AudioAuditEvent = Schemas$16["AudioAuditEvent"];
+type AudioAuditKind = Schemas$16["AudioAuditKind"];
 type AudioHint = Schemas$16["AudioHint"];
 type AudioLocation = Schemas$16["AudioLocation"];
-type AudioProvenance = Schemas$16["AudioProvenance"];
+type AudioAuditLog = Schemas$16["AudioAuditLog"];
 type AudioData = Schemas$16["AudioData"];
 type TabularEntity = Schemas$16["TabularEntity"];
 type TabularEntityRecord = Schemas$16["TabularEntityRecord"];
-type TabularEvent = Schemas$16["TabularEvent"];
-type TabularEventKind = Schemas$16["TabularEventKind"];
+type TabularAuditEvent = Schemas$16["TabularAuditEvent"];
+type TabularAuditKind = Schemas$16["TabularAuditKind"];
 type TabularHint = Schemas$16["TabularHint"];
 type TabularLocation = Schemas$16["TabularLocation"];
-type TabularProvenance = Schemas$16["TabularProvenance"];
+type TabularAuditLog = Schemas$16["TabularAuditLog"];
 //#endregion
 //#region src/datatypes/auth.d.ts
 type Schemas$15 = components["schemas"];
@@ -13400,8 +13763,12 @@ type CreatePolicy = Schemas$4["CreatePolicy"];
 type UpdatePolicy = Schemas$4["UpdatePolicy"];
 type PolicyRule = Schemas$4["PolicyRule"];
 type PolicyTemplate = Schemas$4["PolicyTemplate"];
+type HipaaDeidentification = Schemas$4["HipaaDeidentification"];
 type HipaaDeidMethod = Schemas$4["HipaaDeidMethod"];
+type HipaaAccountNumbers = Schemas$4["HipaaAccountNumbers"];
+type GdprArticle9 = Schemas$4["GdprArticle9"];
 type GdprArticle9Treatment = Schemas$4["GdprArticle9Treatment"];
+type GdprSensitiveScope = Schemas$4["GdprSensitiveScope"];
 type PciDssPart = Schemas$4["PciDssPart"];
 type PciPanRender = Schemas$4["PciPanRender"];
 type Predicate = Schemas$4["Predicate"];
@@ -13473,5 +13840,5 @@ type Retention = Schemas["Retention"];
 type RetentionSettings = Schemas["RetentionSettings"];
 type RetentionOverride = Schemas["RetentionOverride"];
 //#endregion
-export { ModalityRedactions as $, AudioEventKind as $n, ConnectionActivityParams as $r, InvitePage as $t, PipelineRun as A, LlmConfig as An, TabularEventKind as Ar, Notification as At, CreatePolicy as B, SyncTriggerType as Bn, TextLocation as Br, UnreadCountEvent as Bt, LanguageProvenance as C, ConnectionPage as Cn, Polygon as Cr, UpdatePipeline as Ct, ScopeParams as D, ConnectionsQuery as Dn, TabularEntity as Dr, MarkedReadStatus as Dt, ScopeMetadata as E, ConnectionVerification as En, RuleMatch as Er, ConnectionSyncFailedParams as Et, RunStatusEvent as F, SyncDeletionPolicy as Fn, TextEntity as Fr, PipelineRunAnalyzedParams as Ft, ImageRedaction as G, AuthToken as Gn, ApiTokenType as Gr, MemberPage as Gt, DateStyle as H, LabelCatalog as Hn, TimeSpan as Hr, UpdateNotificationSettings as Ht, AudioRedaction as I, SyncMode as In, TextEntityRecord as Ir, PipelineRunCompletedParams as It, LabelGroup as J, Attribution as Jn, TokenExpiration as Jr, CreateInvite as Jt, Label as K, Login as Kn, ApiTokenWithJWT as Kr, MemberSortField as Kt, ClampBucket as L, SyncSchedule as Ln, TextEvent as Lr, PipelineRunFailedParams as Lt, PipelineRunStatus as M, S3Credentials as Mn, TabularLocation as Mr, NotificationPage as Mt, PipelineRunsQuery as N, StorageConfig as Nn, TabularProvenance as Nr, NotificationPayload as Nt, Audit as O, CreateConnection as On, TabularEntityRecord as Or, MemberInvitedParams as Ot, RunMetadata as P, SyncConnection as Pn, TextData as Pr, NotificationSettings as Pt, LocalizedText as Q, AudioEvent as Qn, ActivityPayload as Qr, InviteExpiration as Qt, Color as R, SyncScheduleInput as Rn, TextEventKind as Rr, SystemAnnouncementParams as Rt, Language as S, ConnectionConfig as Sn, Point as Sr, PipelineTriggerType as St, Languages as T, ConnectionSyncPage as Tn, Review as Tr, ConnectionSyncCompletedParams as Tt, GdprArticle9Treatment as U, RecognizerCatalog as Un, ApiToken as Ur, ListMembers as Ut, DateGranularity as V, UpdateConnection as Vn, TextProvenance as Vr, UnreadStatus as Vt, HipaaDeidMethod as W, RegisteredRecognizer as Wn, ApiTokenPage as Wr, Member as Wt, Labels as X, AudioEntity as Xn, Activity as Xr, Invite as Xt, LabelLocale as Y, AudioData as Yn, UpdateApiToken as Yr, GenerateInviteCode as Yt, LanguageTag as Z, AudioEntityRecord as Zn, ActivityPage as Zr, InviteCode as Zt, WebhookPage as _, ErrorResponse as _n, LeakProfile as _r, PipelineDefinition as _t, RetentionSettings as a, PolicyActivityParams as ai, ReplyInvite as an, Dimensions as ar, PolicySummary as at, Confidence as b, AzureCredentials as bn, OperatorId as br, PipelineSummary as bt, WorkspacePage as c, Account as ci, Health as cn, EntityGroup as cr, Predicate as ct, CreateWebhook as d, UpdateAccount as di, FileKind as dn, ImageEntityRecord as dr, TerminalFallback as dt, FileActivityParams as ei, InvitePreview as en, AudioHint as er, PciDssPart as et, TestWebhook as f, paths as fi, FilePage as fn, ImageEvent as fr, TextRedaction as ft, WebhookEvent as g, UpdateFile as gn, ImageProvenance as gr, Pipeline as gt, WebhookCreated as h, ModalityToken as hn, ImageLocation as hr, CreatePipeline as ht, RetentionOverride as i, PipelineRunActivityParams as ii, ListInvites as in, BoundingBox as ir, PolicyRule as it, PipelineRunPage as j, OpenAiCredentials as jn, TabularHint as jr, NotificationEvent as jt, CreatePipelineRun as k, GcsCredentials as kn, TabularEvent as kr, MemberJoinedParams as kt, WorkspaceRole as l, AccountRef as li, HealthStatus as ln, ImageData as lr, Sha2Algorithm as lt, Webhook as m, ListFiles as mn, ImageHint as mr, Waveform as mt, OcrPolicy as n, MemberActivityParams as ni, InviteSortField as nn, AudioProvenance as nr, Policy as nt, UpdateWorkspace as o, WebhookActivityParams as oi, SortOrder as on, Dpi as or, PolicySummaryPage as ot, UpdateWebhook as p, FormatToken as pn, ImageEventKind as pr, UpdatePolicy as pt, LabelEntry as q, Signup as qn, CreateApiToken as qr, UpdateMember as qt, Retention as r, PipelineActivityParams as ri, InviteStatus as rn, AuditContext as rr, PolicyDefinition as rt, Workspace as s, WorkspaceActivityParams as si, ComponentHealth as sn, EntityCoRef as sr, PolicyTemplate as st, CreateWorkspace as t, InviteActivityParams as ti, InviteSent as tn, AudioLocation as tr, PciPanRender as tt, WorkspaceSettings as u, PublicAccount as ui, File as un, ImageEntity as ur, TabularRedaction as ut, WebhookResult as v, ValidationErrorDetail as vn, ModelEvent as vr, PipelineFilter as vt, LanguageSpan as w, ConnectionSync as wn, RangeOfUint as wr, CursorPagination as wt, CountryCode as x, Connection as xn, PatternEvent as xr, PipelineSummaryPage as xt, WebhookStatus as y, AnthropicCredentials as yn, OcrMode as yr, PipelineStatus as yt, ConfidenceThreshold as z, SyncStatus as zn, TextHint as zr, SystemReportParams as zt };
-//# sourceMappingURL=index-Cijg5CMy.d.ts.map
+export { LabelLocale as $, AudioAuditEvent as $n, CreateApiToken as $r, GenerateInviteCode as $t, PipelineRun as A, ConnectionVerification as An, RangeOfUint as Ar, ConnectionSyncFailedParams as At, CreatePolicy as B, SyncMode as Bn, TextAuditEvent as Br, PipelineRunCompletedParams as Bt, LanguageProvenance as C, AnthropicCredentials as Cn, LeakProfile as Cr, PipelineStatus as Ct, ScopeParams as D, ConnectionPage as Dn, PatternEvent as Dr, UpdatePipeline as Dt, ScopeMetadata as E, ConnectionConfig as En, OperatorId as Er, PipelineTriggerType as Et, RunStatusEvent as F, OpenAiCredentials as Fn, TabularAuditLog as Fr, NotificationEvent as Ft, GdprSensitiveScope as G, UpdateConnection as Gn, TextEntityRecord as Gr, UnreadStatus as Gt, DateStyle as H, SyncScheduleInput as Hn, TextAuditLog as Hr, SystemAnnouncementParams as Ht, AudioRedaction as I, S3Credentials as In, TabularEntity as Ir, NotificationPage as It, HipaaDeidentification as J, RegisteredRecognizer as Jn, TimeSpan as Jr, Member as Jt, HipaaAccountNumbers as K, LabelCatalog as Kn, TextHint as Kr, UpdateNotificationSettings as Kt, ClampBucket as L, StorageConfig as Ln, TabularEntityRecord as Lr, NotificationPayload as Lt, PipelineRunStatus as M, CreateConnection as Mn, RuleMatch as Mr, MemberInvitedParams as Mt, PipelineRunsQuery as N, GcsCredentials as Nn, TabularAuditEvent as Nr, MemberJoinedParams as Nt, Audit as O, ConnectionSync as On, Point as Or, CursorPagination as Ot, RunMetadata as P, LlmConfig as Pn, TabularAuditKind as Pr, Notification as Pt, LabelGroup as Q, Attribution as Qn, ApiTokenWithJWT as Qr, CreateInvite as Qt, Color as R, SyncConnection as Rn, TabularHint as Rr, NotificationSettings as Rt, Language as S, ValidationErrorDetail as Sn, ImageLocation as Sr, PipelineFilter as St, Languages as T, Connection as Tn, OcrMode as Tr, PipelineSummaryPage as Tt, GdprArticle9 as U, SyncStatus as Un, TextData as Ur, SystemReportParams as Ut, DateGranularity as V, SyncSchedule as Vn, TextAuditKind as Vr, PipelineRunFailedParams as Vt, GdprArticle9Treatment as W, SyncTriggerType as Wn, TextEntity as Wr, UnreadCountEvent as Wt, Label as X, Login as Xn, ApiTokenPage as Xr, MemberSortField as Xt, ImageRedaction as Y, AuthToken as Yn, ApiToken as Yr, MemberPage as Yt, LabelEntry as Z, Signup as Zn, ApiTokenType as Zr, UpdateMember as Zt, WebhookPage as _, UpdateAccount as _i, FormatToken as _n, ImageAuditLog as _r, UpdatePolicy as _t, RetentionSettings as a, ConnectionActivityParams as ai, InviteSent as an, AudioHint as ar, PciPanRender as at, Confidence as b, UpdateFile as bn, ImageEntityRecord as br, Pipeline as bt, WorkspacePage as c, MemberActivityParams as ci, ListInvites as cn, AuditHash as cr, PolicyRule as ct, CreateWebhook as d, PolicyActivityParams as di, ComponentHealth as dn, Dimensions as dr, PolicyTemplate as dt, TokenExpiration as ei, Invite as en, AudioAuditKind as er, Labels as et, TestWebhook as f, WebhookActivityParams as fi, Health as fn, Dpi as fr, Predicate as ft, WebhookEvent as g, PublicAccount as gi, FilePage as gn, ImageAuditKind as gr, TextRedaction as gt, WebhookCreated as h, AccountRef as hi, FileKind as hn, ImageAuditEvent as hr, TerminalFallback as ht, RetentionOverride as i, ActivityPayload as ii, InvitePreview as in, AudioEntityRecord as ir, PciDssPart as it, PipelineRunPage as j, ConnectionsQuery as jn, Review as jr, MarkedReadStatus as jt, CreatePipelineRun as k, ConnectionSyncPage as kn, Polygon as kr, ConnectionSyncCompletedParams as kt, WorkspaceRole as l, PipelineActivityParams as li, ReplyInvite as ln, BoundingBox as lr, PolicySummary as lt, Webhook as m, Account as mi, File as mn, EntityGroup as mr, TabularRedaction as mt, OcrPolicy as n, Activity as ni, InviteExpiration as nn, AudioData as nr, LocalizedText as nt, UpdateWorkspace as o, FileActivityParams as oi, InviteSortField as on, AudioLocation as or, Policy as ot, UpdateWebhook as p, WorkspaceActivityParams as pi, HealthStatus as pn, EntityCoRef as pr, Sha2Algorithm as pt, HipaaDeidMethod as q, RecognizerCatalog as qn, TextLocation as qr, ListMembers as qt, Retention as r, ActivityPage as ri, InvitePage as rn, AudioEntity as rr, ModalityRedactions as rt, Workspace as s, InviteActivityParams as si, InviteStatus as sn, AuditContext as sr, PolicyDefinition as st, CreateWorkspace as t, UpdateApiToken as ti, InviteCode as tn, AudioAuditLog as tr, LanguageTag as tt, WorkspaceSettings as u, PipelineRunActivityParams as ui, SortOrder as un, Category as ur, PolicySummaryPage as ut, WebhookResult as v, paths as vi, ListFiles as vn, ImageData as vr, Waveform as vt, LanguageSpan as w, AzureCredentials as wn, ModelEvent as wr, PipelineSummary as wt, CountryCode as x, ErrorResponse as xn, ImageHint as xr, PipelineDefinition as xt, WebhookStatus as y, ModalityToken as yn, ImageEntity as yr, CreatePipeline as yt, ConfidenceThreshold as z, SyncDeletionPolicy as zn, TabularLocation as zr, PipelineRunAnalyzedParams as zt };
+//# sourceMappingURL=index-Zd5G8h44.d.ts.map