@nvisy/sdk 0.24.0 → 0.26.0

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

@@ -5958,6 +5958,60 @@ interface paths {
     patch?: never;
     trace?: never;
   };
+  "/notifications/unread/events/": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Stream unread notifications count
+     * @description Opens a Server-Sent Events stream of the account's unread notification count. Emits the current count immediately, then each change as notifications arrive or are marked read, until the client disconnects. Each event's `data` is an `UnreadCountEvent` (see the response schema). Authenticate with a Bearer token via a `fetch`-based client; the native `EventSource` cannot send an `Authorization` header.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path?: never;
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Server-sent event stream; each event's `data` is the payload below. */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "text/event-stream": components["schemas"]["UnreadCountEvent"];
+          };
+        };
+        /**
+         * @description HTTP error response representation with security-conscious design.
+         *
+         *     This struct contains all the information needed to serialize an error
+         *     response, including the error name, message, HTTP status code, resource
+         *     information, and user-friendly messages.
+         */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            "application/json": components["schemas"]["ErrorResponse"];
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   "/notifications/read/": {
     parameters: {
       query?: never;
@@ -7688,13 +7742,6 @@ interface paths {
       };
       requestBody?: never;
       responses: {
-        /** @description no content */
-        200: {
-          headers: {
-            [name: string]: unknown;
-          };
-          content?: never;
-        };
         /**
          * @description HTTP error response representation with security-conscious design.
          *
@@ -7745,13 +7792,6 @@ interface paths {
       };
       requestBody?: never;
       responses: {
-        /** @description no content */
-        200: {
-          headers: {
-            [name: string]: unknown;
-          };
-          content?: never;
-        };
         /**
          * @description HTTP error response representation with security-conscious design.
          *
@@ -7832,22 +7872,28 @@ interface components {
       /** @description Handle of the account. */
       username: components["schemas"]["Handle"];
     };
-    /** @description Response type for a workspace activity. */
+    /**
+     * @description Response type for a workspace activity.
+     *
+     *     The typed payload is nested under `payload`, so an activity is
+     *     `{ id, workspaceSlug, performedBy, payload: { activityType, <params...> }, createdAt }`.
+     */
     Activity: {
-      /** @description Type of activity. */
-      activityType: components["schemas"]["ActivityType"];
       /**
        * Format: date-time
        * @description When the activity occurred.
        */
       createdAt: string;
-      /** @description Human-readable description. */
-      description: string;
       /**
        * Format: uuid
        * @description Unique activity identifier.
        */
       id: string;
+      /**
+       * @description The activity type and its typed params, absent when the stored params do
+       *     not decode into their `activityType`.
+       */
+      payload?: components["schemas"]["ActivityPayload"];
       /** @description Account that performed the activity. */
       performedBy: components["schemas"]["AccountRef"];
       /** @description Handle of the workspace this activity belongs to. */
@@ -7872,13 +7918,112 @@ interface components {
       total?: number;
     };
     /**
-     * @description Defines the type of activity performed in a workspace for audit logging.
+     * @description The typed payload of an audit-log activity, tagged by `activityType`.
      *
-     *     This enumeration corresponds to the `ACTIVITY_TYPE` PostgreSQL enum and is used
-     *     to categorize different types of activities that occur within workspaces for comprehensive
-     *     audit trail and activity tracking.
+     *     Each variant is one activity type carrying its own params. No rendered text is
+     *     included — the client localizes the copy from `activityType` and the params.
+     *     The `activityType` values match the `ACTIVITY_TYPE` enum.
      */
-    ActivityType: "workspace:created" | "workspace:updated" | "workspace:deleted" | "workspace:exported" | "workspace:imported" | "member:deleted" | "member:updated" | "invite:created" | "invite:accepted" | "invite:declined" | "invite:canceled" | "connection:created" | "connection:updated" | "connection:deleted" | "connection:synced" | "webhook:created" | "webhook:updated" | "webhook:deleted" | "webhook:triggered" | "file:created" | "file:updated" | "file:deleted" | "file:verified" | "custom";
+    ActivityPayload: ({
+      /** @constant */
+      activityType: "workspace.created";
+    } & components["schemas"]["WorkspaceActivityParams"]) | ({
+      /** @constant */
+      activityType: "workspace.updated";
+    } & components["schemas"]["WorkspaceActivityParams"]) | ({
+      /** @constant */
+      activityType: "workspace.deleted";
+    } & components["schemas"]["WorkspaceActivityParams"]) | ({
+      /** @constant */
+      activityType: "member.added";
+    } & components["schemas"]["MemberActivityParams"]) | ({
+      /** @constant */
+      activityType: "member.updated";
+    } & components["schemas"]["MemberActivityParams"]) | ({
+      /** @constant */
+      activityType: "member.deleted";
+    } & components["schemas"]["MemberActivityParams"]) | ({
+      /** @constant */
+      activityType: "invite.created";
+    } & components["schemas"]["InviteActivityParams"]) | ({
+      /** @constant */
+      activityType: "invite.accepted";
+    } & components["schemas"]["InviteActivityParams"]) | ({
+      /** @constant */
+      activityType: "invite.declined";
+    } & components["schemas"]["InviteActivityParams"]) | ({
+      /** @constant */
+      activityType: "invite.canceled";
+    } & components["schemas"]["InviteActivityParams"]) | ({
+      /** @constant */
+      activityType: "connection.created";
+    } & components["schemas"]["ConnectionActivityParams"]) | ({
+      /** @constant */
+      activityType: "connection.updated";
+    } & components["schemas"]["ConnectionActivityParams"]) | ({
+      /** @constant */
+      activityType: "connection.deleted";
+    } & components["schemas"]["ConnectionActivityParams"]) | ({
+      /** @constant */
+      activityType: "connection.sync.completed";
+    } & components["schemas"]["ConnectionActivityParams"]) | ({
+      /** @constant */
+      activityType: "connection.sync.failed";
+    } & components["schemas"]["ConnectionActivityParams"]) | ({
+      /** @constant */
+      activityType: "webhook.created";
+    } & components["schemas"]["WebhookActivityParams"]) | ({
+      /** @constant */
+      activityType: "webhook.updated";
+    } & components["schemas"]["WebhookActivityParams"]) | ({
+      /** @constant */
+      activityType: "webhook.deleted";
+    } & components["schemas"]["WebhookActivityParams"]) | ({
+      /** @constant */
+      activityType: "webhook.triggered";
+    } & components["schemas"]["WebhookActivityParams"]) | ({
+      /** @constant */
+      activityType: "file.created";
+    } & components["schemas"]["FileActivityParams"]) | ({
+      /** @constant */
+      activityType: "file.updated";
+    } & components["schemas"]["FileActivityParams"]) | ({
+      /** @constant */
+      activityType: "file.deleted";
+    } & components["schemas"]["FileActivityParams"]) | ({
+      /** @constant */
+      activityType: "file.verified";
+    } & components["schemas"]["FileActivityParams"]) | ({
+      /** @constant */
+      activityType: "pipeline.created";
+    } & components["schemas"]["PipelineActivityParams"]) | ({
+      /** @constant */
+      activityType: "pipeline.updated";
+    } & components["schemas"]["PipelineActivityParams"]) | ({
+      /** @constant */
+      activityType: "pipeline.deleted";
+    } & components["schemas"]["PipelineActivityParams"]) | ({
+      /** @constant */
+      activityType: "pipeline.run.started";
+    } & components["schemas"]["PipelineRunActivityParams"]) | ({
+      /** @constant */
+      activityType: "pipeline.run.analyzed";
+    } & components["schemas"]["PipelineRunActivityParams"]) | ({
+      /** @constant */
+      activityType: "pipeline.run.completed";
+    } & components["schemas"]["PipelineRunActivityParams"]) | ({
+      /** @constant */
+      activityType: "pipeline.run.failed";
+    } & components["schemas"]["PipelineRunActivityParams"]) | ({
+      /** @constant */
+      activityType: "policy.created";
+    } & components["schemas"]["PolicyActivityParams"]) | ({
+      /** @constant */
+      activityType: "policy.updated";
+    } & components["schemas"]["PolicyActivityParams"]) | ({
+      /** @constant */
+      activityType: "policy.deleted";
+    } & components["schemas"]["PolicyActivityParams"]);
     /** @description Anthropic API credentials. */
     AnthropicCredentials: {
       /** @description Anthropic API key. */
@@ -7984,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. */
@@ -7993,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;
-      /**
-       * @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"];
+    AudioAuditEvent: {
       /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      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. */
@@ -8220,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
        */
@@ -8238,77 +8303,216 @@ 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 Located, typed piece of context a recognizer may treat as in-context
-     *     for a nearby value.
+     * @description Full audit trail of an [`Entity`]: every [`AuditEvent`] in its life, as a
+     *     tamper-evident DAG.
      *
-     *     Out-of-band by nature: a hint is *not* a sub-span of the value it
-     *     informs — it lives elsewhere in the source (a table's column header, a
-     *     JSON object key, a log field name). So `location` points at where the
-     *     hint text actually sits, and `data` is the hint text itself. Carrying
-     *     the location (rather than a bare string) lets a confidence boost record
-     *     *which* hint lifted a score and *where* it came from — provenance a
-     *     review consumer can resolve back to the document.
+     *     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.
      *
-     *     Mirrors [`Entity`]'s `location` + `data` shape, so the same
-     *     serialization and lifting patterns apply.
+     *     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).
      *
-     *     [`Entity`]: crate::entity::Entity
-     */
-    AudioHint: {
-      /** @description The hint text itself (a column header, a field name). */
-      data: components["schemas"]["AudioData"];
-      /** @description Where the hint text sits in the source (the header cell, the key). */
-      location: components["schemas"]["AudioLocation"];
-    };
-    /**
-     * @description A [`TimeSpan`] within audio content, with an optional speaker label.
+     *     Two chains ride the DAG's edges:
      *
-     *     The time span is the coordinate; ordering and overlap consider only it.
-     *     The optional [`speaker_id`] is a diarization label,
-     *     not a coordinate: two utterances from different speakers at the same
-     *     instant still overlap in time, so the speaker is carried for provenance
-     *     but excluded from comparison.
+     *     - 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.
      *
-     *     [`speaker_id`]: Self::speaker_id
+     *     [`Entity`]: crate::entity::Entity
+     *     [`confidence`]: AuditEvent::confidence
+     *     [`hash`]: AuditEvent::hash
+     *     [`final_confidence`]: Self::final_confidence
+     *     [`verify`]: Self::verify
      */
-    AudioLocation: {
-      /** @description Time span the location covers, in the stream's timeline. */
-      span: components["schemas"]["TimeSpan"];
-      /** @description Diarization label of the speaker, when a diarizer assigned one. */
-      speaker_id?: string;
-    };
+    AudioAuditLog: components["schemas"]["AudioAuditEvent"][];
     /**
-     * @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.
+     * @description Per-call payload a recognizer inspects for the [`Audio`] modality.
      *
-     *     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.
+     *     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
+     *     for a nearby value.
+     *
+     *     Out-of-band by nature: a hint is *not* a sub-span of the value it
+     *     informs — it lives elsewhere in the source (a table's column header, a
+     *     JSON object key, a log field name). So `location` points at where the
+     *     hint text actually sits, and `data` is the hint text itself. Carrying
+     *     the location (rather than a bare string) lets a confidence boost record
+     *     *which* hint lifted a score and *where* it came from — provenance a
+     *     review consumer can resolve back to the document.
+     *
+     *     Mirrors [`Entity`]'s `location` + `data` shape, so the same
+     *     serialization and lifting patterns apply.
      *
      *     [`Entity`]: crate::entity::Entity
-     *     [`after`]: Event::after
-     *     [`before`]: Event::before
      */
-    AudioProvenance: {
-      /** @description Events, in the order they happened. */
-      events: components["schemas"]["AudioEvent"][];
+    AudioHint: {
+      /** @description The hint text itself (a column header, a field name). */
+      data: components["schemas"]["AudioData"];
+      /** @description Where the hint text sits in the source (the header cell, the key). */
+      location: components["schemas"]["AudioLocation"];
+    };
+    /**
+     * @description A [`TimeSpan`] within audio content, with an optional speaker label.
+     *
+     *     The time span is the coordinate; ordering and overlap consider only it.
+     *     The optional [`speaker_id`] is a diarization label,
+     *     not a coordinate: two utterances from different speakers at the same
+     *     instant still overlap in time, so the speaker is carried for provenance
+     *     but excluded from comparison.
+     *
+     *     [`speaker_id`]: Self::speaker_id
+     */
+    AudioLocation: {
+      /** @description Time span the location covers, in the stream's timeline. */
+      span: components["schemas"]["TimeSpan"];
+      /** @description Diarization label of the speaker, when a diarizer assigned one. */
+      speaker_id?: string;
     };
     /** @description Operator spec a `redact` audio rule carries. */
     AudioRedaction: {
@@ -8466,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. */
@@ -8545,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.
      *
@@ -8605,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]`.
@@ -8615,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;
@@ -8662,6 +8899,14 @@ interface components {
       /** @description Handle of the workspace this connection belongs to. */
       workspaceSlug: components["schemas"]["Handle"];
     };
+    /** @description Params of a connection activity (`connection.*`). */
+    ConnectionActivityParams: {
+      /**
+       * Format: uuid
+       * @description Id of the connection.
+       */
+      connectionId: string;
+    };
     /**
      * @description A fully-typed connection configuration for any capability.
      *
@@ -8739,7 +8984,7 @@ interface components {
       /** @description Account that triggered the sync. */
       triggeredBy: components["schemas"]["AccountRef"];
     };
-    /** @description Params of a `connection:sync.completed` notification. */
+    /** @description Params of a `connection.sync.completed` notification. */
     ConnectionSyncCompletedParams: {
       /**
        * Format: uuid
@@ -8752,7 +8997,7 @@ interface components {
        */
       recordsSynced?: number;
     };
-    /** @description Params of a `connection:sync.failed` notification. */
+    /** @description Params of a `connection.sync.failed` notification. */
     ConnectionSyncFailedParams: {
       /**
        * Format: uuid
@@ -9163,6 +9408,16 @@ interface components {
       /** @description Handle of the workspace this file belongs to. */
       workspaceSlug: components["schemas"]["Handle"];
     };
+    /** @description Params of a file activity (`file.*`). */
+    FileActivityParams: {
+      /**
+       * Format: uuid
+       * @description Id of the file.
+       */
+      fileId: string;
+      /** @description Display name of the file. */
+      fileName: string;
+    };
     /**
      * @description The role a file plays, which drives its data-retention scope and whether it
      *     is a user-facing document.
@@ -9221,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.
      *
@@ -9235,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. */
@@ -9255,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.
      *
@@ -9280,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;
-      /**
-       * @description What kind of sensitive information this is (resolved via a
-       *     [`LabelCatalog`]).
-       */
-      label: components["schemas"]["LabelRef"];
+    ImageAuditEvent: {
       /**
-       * @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;
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
+       * @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.
+       *
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      location: components["schemas"]["ImageLocation"];
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["ImageAuditKind"];
       /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
+       * @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
        */
-      provenance: components["schemas"]["ImageProvenance"];
+      parents: components["schemas"]["AuditHash"][];
       /**
-       * @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.
-       *
-       *     [`location`]: Entity::location
+       * @description Who produced this event: a recognizer name, a deduplication strategy,
+       *     an operator, or whatever acted.
        */
-      recognized_range?: components["schemas"]["Range_of_uint"];
+      source: string;
+      /** @description When the event happened (UTC). */
+      timestamp: string;
     };
     /**
-     * @description One recognized entity plus the optional reviewer override.
+     * @description Kind of an [`AuditEvent`], carrying its event-specific detail and the
+     *     rationale for why it happened.
      *
-     *     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.
+     *     `#[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`]: AuditKind::Pattern
+     *     [`Model`]: AuditKind::Model
+     *     [`Location`]: Modality::Location
      */
-    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 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;
-      /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
-       */
-      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;
-      /**
-       * @description Who produced this event: a recognizer name, a deduplication strategy,
-       *     an operator, or whatever acted.
-       */
-      source: string;
-    };
-    /**
-     * @description Kind of an [`Event`], carrying its event-specific detail.
-     *
-     *     `#[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
-     *     [`Location`]: Modality::Location
-     */
-    ImageEventKind: {
+    ImageAuditKind: {
       /** @constant */
       kind: "pattern";
       /** @description Where the recognizer matched. */
@@ -9505,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
        */
@@ -9523,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
@@ -9575,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 */
@@ -9679,6 +10085,16 @@ interface components {
       /** @description Handle of the workspace the invitation is for. */
       workspaceSlug: components["schemas"]["Handle"];
     };
+    /** @description Params of an invite activity (`invite.*`). */
+    InviteActivityParams: {
+      /** @description Email the invite was addressed to. */
+      email: string;
+      /**
+       * Format: uuid
+       * @description Id of the invite.
+       */
+      inviteId: string;
+    };
     /** @description Response containing a generated shareable invite code. */
     InviteCode: {
       /**
@@ -9774,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
      *
@@ -9792,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[];
@@ -10158,14 +10581,19 @@ interface components {
       /** @description Handle of the member's account. */
       username: components["schemas"]["Handle"];
     };
-    /** @description Params of a `member:invited` notification. */
+    /** @description Params of a member activity (`member.*`). */
+    MemberActivityParams: {
+      /** @description Username of the member acted on. */
+      memberUsername: components["schemas"]["Handle"];
+    };
+    /** @description Params of a `member.invited` notification. */
     MemberInvitedParams: {
       /** @description Username of the account that sent the invite, if known. */
       invitedBy?: string;
       /** @description Slug of the workspace the account was invited to. */
       workspaceSlug: string;
     };
-    /** @description Params of a `member:joined` notification. */
+    /** @description Params of a `member.joined` notification. */
     MemberJoinedParams: {
       /** @description Username of the member that joined. */
       memberUsername: string;
@@ -10235,8 +10663,8 @@ interface components {
     /**
      * @description Response type for an account notification.
      *
-     *     The typed [`NotificationPayload`] is nested under `payload`, so a notification
-     *     is `{ id, payload: { notifyType, <params...> }, isRead, ... }`.
+     *     The typed payload is nested under `payload`, so a notification is
+     *     `{ id, payload: { notifyType, <params...> }, readAt, ... }`.
      */
     Notification: {
       /**
@@ -10254,13 +10682,14 @@ interface components {
        * @description Unique notification identifier.
        */
       id: string;
-      /** @description Whether the notification has been read. */
-      isRead: boolean;
-      /** @description The notification type and its typed params. */
-      payload: components["schemas"]["NotificationPayload"];
+      /**
+       * @description The notification type and its typed params, absent when the stored params
+       *     do not decode into their `notifyType`.
+       */
+      payload?: components["schemas"]["NotificationPayload"];
       /**
        * Format: date-time
-       * @description When the notification was read.
+       * @description When the notification was read; absent means unread.
        */
       readAt?: string;
     };
@@ -10272,7 +10701,7 @@ interface components {
      *     The values mirror the [`WebhookEvent`](super::WebhookEvent) naming for the
      *     events the two channels share.
      */
-    NotificationEvent: "member:invited" | "member:joined" | "connection:sync.completed" | "connection:sync.failed" | "pipeline:run.analyzed" | "pipeline:run.completed" | "pipeline:run.failed" | "system:announcement" | "system:report";
+    NotificationEvent: "member.invited" | "member.joined" | "connection.sync.completed" | "connection.sync.failed" | "pipeline.run.analyzed" | "pipeline.run.completed" | "pipeline.run.failed" | "system.announcement" | "system.report";
     /**
      * @description Generic paginated response wrapper.
      *
@@ -10307,38 +10736,37 @@ interface components {
     /**
      * @description The typed payload of a notification, tagged by `notifyType`.
      *
-     *     Each variant is one notification type carrying its own params struct. No
-     *     rendered text is included — the client localizes the copy from `notifyType`
-     *     and the params. The `notifyType` values match the `NOTIFICATION_EVENT` enum,
-     *     so the same key drives the member's per-event preferences.
+     *     Each variant is one notification type carrying its own params struct. The
+     *     `notifyType` values match [`NotificationEvent`], so the same key drives the
+     *     member's per-event preferences.
      */
     NotificationPayload: ({
       /** @constant */
-      notifyType: "member:invited";
+      notifyType: "member.invited";
     } & components["schemas"]["MemberInvitedParams"]) | ({
       /** @constant */
-      notifyType: "member:joined";
+      notifyType: "member.joined";
     } & components["schemas"]["MemberJoinedParams"]) | ({
       /** @constant */
-      notifyType: "connection:sync.completed";
+      notifyType: "connection.sync.completed";
     } & components["schemas"]["ConnectionSyncCompletedParams"]) | ({
       /** @constant */
-      notifyType: "connection:sync.failed";
+      notifyType: "connection.sync.failed";
     } & components["schemas"]["ConnectionSyncFailedParams"]) | ({
       /** @constant */
-      notifyType: "pipeline:run.analyzed";
+      notifyType: "pipeline.run.analyzed";
     } & components["schemas"]["PipelineRunAnalyzedParams"]) | ({
       /** @constant */
-      notifyType: "pipeline:run.completed";
+      notifyType: "pipeline.run.completed";
     } & components["schemas"]["PipelineRunCompletedParams"]) | ({
       /** @constant */
-      notifyType: "pipeline:run.failed";
+      notifyType: "pipeline.run.failed";
     } & components["schemas"]["PipelineRunFailedParams"]) | ({
       /** @constant */
-      notifyType: "system:announcement";
+      notifyType: "system.announcement";
     } & components["schemas"]["SystemAnnouncementParams"]) | ({
       /** @constant */
-      notifyType: "system:report";
+      notifyType: "system.report";
     } & components["schemas"]["SystemReportParams"]);
     /** @description Response for notification settings within a workspace. */
     NotificationSettings: {
@@ -10497,6 +10925,11 @@ interface components {
       /** @description Handle of the workspace this pipeline belongs to. */
       workspaceSlug: components["schemas"]["Handle"];
     };
+    /** @description Params of a pipeline activity (`pipeline.*`, non-run). */
+    PipelineActivityParams: {
+      /** @description Slug of the pipeline. */
+      pipelineSlug: components["schemas"]["Handle"];
+    };
     /**
      * @description A pipeline's detection + governance intent.
      *
@@ -10570,7 +11003,7 @@ interface components {
        */
       inputFileName?: string;
       /** @description Non-encrypted metadata for filtering/display. */
-      metadata: unknown;
+      metadata: components["schemas"]["RunMetadata"];
       /**
        * Format: uuid
        * @description Redacted document produced by the run, once it completes.
@@ -10599,7 +11032,17 @@ interface components {
       /** @description Handle of the workspace this run belongs to. */
       workspaceSlug: components["schemas"]["Handle"];
     };
-    /** @description Params of a `pipeline:run.analyzed` notification. */
+    /** @description Params of a pipeline-run activity (`pipeline.run.*`). */
+    PipelineRunActivityParams: {
+      /** @description Slug of the owning pipeline. */
+      pipelineSlug: components["schemas"]["Handle"];
+      /**
+       * Format: uuid
+       * @description Id of the run.
+       */
+      runId: string;
+    };
+    /** @description Params of a `pipeline.run.analyzed` notification. */
     PipelineRunAnalyzedParams: {
       /** @description Display name of the analyzed file, if known. */
       inputFileName?: string;
@@ -10611,7 +11054,7 @@ interface components {
        */
       runId: string;
     };
-    /** @description Params of a `pipeline:run.completed` notification. */
+    /** @description Params of a `pipeline.run.completed` notification. */
     PipelineRunCompletedParams: {
       /** @description Display name of the analyzed file, if known. */
       inputFileName?: string;
@@ -10623,7 +11066,7 @@ interface components {
        */
       runId: string;
     };
-    /** @description Params of a `pipeline:run.failed` notification. */
+    /** @description Params of a `pipeline.run.failed` notification. */
     PipelineRunFailedParams: {
       /** @description Failure reason, if available. */
       error?: string;
@@ -10796,6 +11239,14 @@ interface components {
       /** @description Handle of the workspace this policy belongs to. */
       workspaceSlug: components["schemas"]["Handle"];
     };
+    /** @description Params of a policy activity (`policy.*`). */
+    PolicyActivityParams: {
+      /**
+       * Format: uuid
+       * @description Id of the policy.
+       */
+      policyId: string;
+    };
     /**
      * @description A named governance policy.
      *
@@ -10831,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;
       /**
@@ -10879,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. */
@@ -10971,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";
       /**
@@ -10998,6 +11439,9 @@ interface components {
     } | {
       /** @constant */
       kind: "ccpa";
+    } | {
+      /** @constant */
+      kind: "soc2_secrets";
     };
     /**
      * @description Closed polygon, given by its ordered vertices.
@@ -11238,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: {
@@ -11248,6 +11692,13 @@ interface components {
     } | "predicate" | "fallback";
     /** @description Opaque run identifier (run_<uuid>). */
     RunId: string;
+    /** @description Structured metadata for a pipeline run. */
+    RunMetadata: {
+      /** @description Failure reason recorded when the run failed. */
+      error?: string;
+      /** @description Free-form labels attached to the run. */
+      tags?: string[];
+    };
     /**
      * @description A run's status change, broadcast on the core-NATS subject [`run_subject`].
      *
@@ -11559,12 +12010,12 @@ interface components {
      *     to track whether a run was manually triggered, scheduled, or triggered by a webhook.
      */
     SyncTriggerType: "manual" | "scheduled" | "webhook";
-    /** @description Params of a `system:announcement` notification. */
+    /** @description Params of a `system.announcement` notification. */
     SystemAnnouncementParams: {
       /** @description Announcement message key or body. */
       message: string;
     };
-    /** @description Params of a `system:report` notification. */
+    /** @description Params of a `system.report` notification. */
     SystemReportParams: {
       /**
        * Format: uuid
@@ -11573,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"];
-      /**
-       * Format: uuid
-       * @description Stable unique identity for this entity (time-ordered UUIDv7), minted
-       *     when the entity is assembled.
-       */
-      id: string;
+    TabularAuditEvent: {
       /**
-       * @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"];
+      confidence: components["schemas"]["Confidence"];
       /**
-       * @description The language of this entity's surrounding text, when a recognizer
-       *     resolved one. `None` when unknown or language-agnostic.
+       * @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.
+       *
+       *     Not publicly settable: only [`AuditLog`] assigns it, so a caller cannot
+       *     forge a self-consistent event outside the recording path.
+       *
+       *     [`AuditLog`]: crate::entity::audit::AuditLog
        */
-      language?: string;
+      hash: components["schemas"]["AuditHash"];
+      /** @description Kind of event, with its event-specific detail and its rationale. */
+      kind: components["schemas"]["TabularAuditKind"];
       /**
-       * @description Location of the entity within the medium (fused, if it came from more
-       *     than one detection).
+       * @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
        */
-      location: components["schemas"]["TabularLocation"];
+      parents: components["schemas"]["AuditHash"][];
       /**
-       * @description Detection audit trail: every contributing detection and the fusion
-       *     event, if any.
-       */
-      provenance: components["schemas"]["TabularProvenance"];
-      /**
-       * @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.
-       *
-       *     [`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 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;
-      /**
-       * @description Confidence before this event, if there was a prior value. `None` on
-       *     the first (birth) event.
-       */
-      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;
-      /**
-       * @description Who produced this event: a recognizer name, a deduplication strategy,
-       *     an operator, or whatever acted.
+       * @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. */
@@ -11782,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
        */
@@ -11800,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
@@ -11877,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 */
@@ -11979,163 +12489,90 @@ interface components {
       payload?: unknown;
     };
     /**
-     * @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.
+     * @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
      */
-    TextEntity: {
-      /** @description Effective confidence in `0.0..=1.0` (fused, if applicable). */
-      confidence: components["schemas"]["Confidence"];
+    TextAuditEvent: {
       /**
-       * @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.
+       * @description Confidence after this event: the entity's effective confidence once it
+       *     has happened.
        */
-      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 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. */
@@ -12199,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
        */
@@ -12217,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
@@ -12271,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 */
@@ -12489,6 +13058,21 @@ interface components {
        */
       tokenId: string;
     };
+    /**
+     * @description An account's current unread-notification count, broadcast on the account's
+     *     core-NATS unread subject.
+     *
+     *     Fan-out to any watching SSE connections so a badge updates live; the stored
+     *     rows in Postgres remain the source of truth, so a missed broadcast is
+     *     recoverable by re-reading the count.
+     */
+    UnreadCountEvent: {
+      /**
+       * Format: int64
+       * @description The account's current number of unread notifications.
+       */
+      unreadCount: number;
+    };
     /** @description Response type for unread notifications status. */
     UnreadStatus: {
       /**
@@ -12699,6 +13283,14 @@ interface components {
       /** @description Handle of the workspace this webhook belongs to. */
       workspaceSlug: components["schemas"]["Handle"];
     };
+    /** @description Params of a webhook activity (`webhook.*`). */
+    WebhookActivityParams: {
+      /**
+       * Format: uuid
+       * @description Id of the webhook.
+       */
+      webhookId: string;
+    };
     /**
      * @description Webhook creation response that includes the secret (visible only once).
      *
@@ -12766,7 +13358,7 @@ interface components {
      *     This enumeration corresponds to the `WEBHOOK_EVENT` PostgreSQL enum and is used
      *     to configure which events a webhook should receive notifications for.
      */
-    WebhookEvent: "file:created" | "file:updated" | "file:deleted" | "member:added" | "member:deleted" | "member:updated" | "connection:created" | "connection:updated" | "connection:deleted" | "connection:sync.started" | "connection:sync.completed" | "connection:sync.failed" | "pipeline:created" | "pipeline:updated" | "pipeline:deleted" | "pipeline:run.started" | "pipeline:run.analyzed" | "pipeline:run.completed" | "pipeline:run.failed" | "policy:created" | "policy:updated" | "policy:deleted";
+    WebhookEvent: "file.created" | "file.updated" | "file.deleted" | "member.added" | "member.deleted" | "member.updated" | "connection.created" | "connection.updated" | "connection.deleted" | "connection.sync.started" | "connection.sync.completed" | "connection.sync.failed" | "pipeline.created" | "pipeline.updated" | "pipeline.deleted" | "pipeline.run.started" | "pipeline.run.analyzed" | "pipeline.run.completed" | "pipeline.run.failed" | "policy.created" | "policy.updated" | "policy.deleted";
     /** @description Opaque whk identifier (whk_<uuid>). */
     WebhookId: string;
     /**
@@ -12840,6 +13432,11 @@ interface components {
        */
       updatedAt: string;
     };
+    /** @description Params of a workspace-scoped activity (`workspace.*`). */
+    WorkspaceActivityParams: {
+      /** @description Slug of the workspace acted on. */
+      workspaceSlug: components["schemas"]["Handle"];
+    };
     /** @description Path parameters for file operations within a workspace context. */
     WorkspaceFilePathParams: {
       /**
@@ -12957,8 +13554,17 @@ type AccountRef = Schemas$19["AccountRef"];
 //#region src/datatypes/activity.d.ts
 type Schemas$18 = components["schemas"];
 type Activity = Schemas$18["Activity"];
-type ActivityType = Schemas$18["ActivityType"];
 type ActivityPage = Schemas$18["ActivityPage"];
+type ActivityPayload = Schemas$18["ActivityPayload"];
+type WorkspaceActivityParams = Schemas$18["WorkspaceActivityParams"];
+type MemberActivityParams = Schemas$18["MemberActivityParams"];
+type InviteActivityParams = Schemas$18["InviteActivityParams"];
+type ConnectionActivityParams = Schemas$18["ConnectionActivityParams"];
+type PipelineActivityParams = Schemas$18["PipelineActivityParams"];
+type PipelineRunActivityParams = Schemas$18["PipelineRunActivityParams"];
+type PolicyActivityParams = Schemas$18["PolicyActivityParams"];
+type FileActivityParams = Schemas$18["FileActivityParams"];
+type WebhookActivityParams = Schemas$18["WebhookActivityParams"];
 //#endregion
 //#region src/datatypes/api-token.d.ts
 type Schemas$17 = components["schemas"];
@@ -12984,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"];
@@ -12993,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"];
@@ -13117,6 +13725,7 @@ type UpdateNotificationSettings = Schemas$7["UpdateNotificationSettings"];
 type UnreadStatus = Schemas$7["UnreadStatus"];
 type NotificationPage = Schemas$7["NotificationPage"];
 type MarkedReadStatus = Schemas$7["MarkedReadStatus"];
+type UnreadCountEvent = Schemas$7["UnreadCountEvent"];
 type NotificationPayload = Schemas$7["NotificationPayload"];
 type MemberInvitedParams = Schemas$7["MemberInvitedParams"];
 type MemberJoinedParams = Schemas$7["MemberJoinedParams"];
@@ -13154,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"];
@@ -13183,6 +13796,7 @@ type TerminalFallback = Schemas$4["TerminalFallback"];
 //#region src/datatypes/run.d.ts
 type Schemas$3 = components["schemas"];
 type PipelineRun = Schemas$3["PipelineRun"];
+type RunMetadata = Schemas$3["RunMetadata"];
 type CreatePipelineRun = Schemas$3["CreatePipelineRun"];
 type PipelineRunStatus = Schemas$3["PipelineRunStatus"];
 type PipelineRunPage = Schemas$3["PipelineRunPage"];
@@ -13226,5 +13840,5 @@ type Retention = Schemas["Retention"];
 type RetentionSettings = Schemas["RetentionSettings"];
 type RetentionOverride = Schemas["RetentionOverride"];
 //#endregion
-export { PciDssPart as $, AudioLocation as $n, PublicAccount as $r, InviteSent as $t, PipelineRun as A, S3Credentials as An, TabularLocation as Ar, NotificationEvent as At, DateGranularity as B, LabelCatalog as Bn, TimeSpan as Br, UpdateNotificationSettings as Bt, LanguageProvenance as C, ConnectionSyncPage as Cn, Review as Cr, CursorPagination as Ct, ScopeParams as D, GcsCredentials as Dn, TabularEvent as Dr, MemberInvitedParams as Dt, ScopeMetadata as E, CreateConnection as En, TabularEntityRecord as Er, MarkedReadStatus as Et, AudioRedaction as F, SyncSchedule as Fn, TextEvent as Fr, PipelineRunCompletedParams as Ft, Label as G, Signup as Gn, CreateApiToken as Gr, UpdateMember as Gt, GdprArticle9Treatment as H, RegisteredRecognizer as Hn, ApiTokenPage as Hr, Member as Ht, ClampBucket as I, SyncScheduleInput as In, TextEventKind as Ir, PipelineRunFailedParams as It, LabelLocale as J, AudioEntity as Jn, Activity as Jr, Invite as Jt, LabelEntry as K, Attribution as Kn, TokenExpiration as Kr, CreateInvite as Kt, Color as L, SyncStatus as Ln, TextHint as Lr, SystemAnnouncementParams as Lt, PipelineRunStatus as M, SyncConnection as Mn, TextData as Mr, NotificationPayload as Mt, PipelineRunsQuery as N, SyncDeletionPolicy as Nn, TextEntity as Nr, NotificationSettings as Nt, Audit as O, LlmConfig as On, TabularEventKind as Or, MemberJoinedParams as Ot, RunStatusEvent as P, SyncMode as Pn, TextEntityRecord as Pr, PipelineRunAnalyzedParams as Pt, ModalityRedactions as Q, AudioHint as Qn, AccountRef as Qr, InvitePreview as Qt, ConfidenceThreshold as R, SyncTriggerType as Rn, TextLocation as Rr, SystemReportParams as Rt, Language as S, ConnectionSync as Sn, RangeOfUint as Sr, UpdatePipeline as St, Languages as T, ConnectionsQuery as Tn, TabularEntity as Tr, ConnectionSyncFailedParams as Tt, HipaaDeidMethod as U, AuthToken as Un, ApiTokenType as Ur, MemberPage as Ut, DateStyle as V, RecognizerCatalog as Vn, ApiToken as Vr, ListMembers as Vt, ImageRedaction as W, Login as Wn, ApiTokenWithJWT as Wr, MemberSortField as Wt, LanguageTag as X, AudioEvent as Xn, ActivityType as Xr, InviteExpiration as Xt, Labels as Y, AudioEntityRecord as Yn, ActivityPage as Yr, InviteCode as Yt, LocalizedText as Z, AudioEventKind as Zn, Account as Zr, InvitePage as Zt, WebhookPage as _, AnthropicCredentials as _n, OcrMode as _r, PipelineFilter as _t, RetentionSettings as a, ComponentHealth as an, EntityCoRef as ar, PolicySummaryPage as at, Confidence as b, ConnectionConfig as bn, Point as br, PipelineSummaryPage as bt, WorkspacePage as c, File as cn, ImageEntity as cr, Sha2Algorithm as ct, CreateWebhook as d, FormatToken as dn, ImageEventKind as dr, TextRedaction as dt, UpdateAccount as ei, InviteSortField as en, AudioProvenance as er, PciPanRender as et, TestWebhook as f, ListFiles as fn, ImageHint as fr, UpdatePolicy as ft, WebhookEvent as g, ValidationErrorDetail as gn, ModelEvent as gr, PipelineDefinition as gt, WebhookCreated as h, ErrorResponse as hn, LeakProfile as hr, Pipeline as ht, RetentionOverride as i, SortOrder as in, Dpi as ir, PolicySummary as it, PipelineRunPage as j, StorageConfig as jn, TabularProvenance as jr, NotificationPage as jt, CreatePipelineRun as k, OpenAiCredentials as kn, TabularHint as kr, Notification as kt, WorkspaceRole as l, FileKind as ln, ImageEntityRecord as lr, TabularRedaction as lt, Webhook as m, UpdateFile as mn, ImageProvenance as mr, CreatePipeline as mt, OcrPolicy as n, ListInvites as nn, BoundingBox as nr, PolicyDefinition as nt, UpdateWorkspace as o, Health as on, EntityGroup as or, PolicyTemplate as ot, UpdateWebhook as p, ModalityToken as pn, ImageLocation as pr, Waveform as pt, LabelGroup as q, AudioData as qn, UpdateApiToken as qr, GenerateInviteCode as qt, Retention as r, ReplyInvite as rn, Dimensions as rr, PolicyRule as rt, Workspace as s, HealthStatus as sn, ImageData as sr, Predicate as st, CreateWorkspace as t, paths as ti, InviteStatus as tn, AuditContext as tr, Policy as tt, WorkspaceSettings as u, FilePage as un, ImageEvent as ur, TerminalFallback as ut, WebhookResult as v, AzureCredentials as vn, OperatorId as vr, PipelineStatus as vt, LanguageSpan as w, ConnectionVerification as wn, RuleMatch as wr, ConnectionSyncCompletedParams as wt, CountryCode as x, ConnectionPage as xn, Polygon as xr, PipelineTriggerType as xt, WebhookStatus as y, Connection as yn, PatternEvent as yr, PipelineSummary as yt, CreatePolicy as z, UpdateConnection as zn, TextProvenance as zr, UnreadStatus as zt };
-//# sourceMappingURL=index-BZcmqZdX.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