@qontinui/shared-types 2.4.0 → 2.5.0

package/src/generated/JourneyGraph.d.ts

@@ -0,0 +1,165 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { FrontierEntry } from "./FrontierEntry";
+import type { JourneyArrivalDoubt } from "./JourneyArrivalDoubt";
+import type { JourneyCoverage } from "./JourneyCoverage";
+import type { JourneyFilter } from "./JourneyFilter";
+import type { JourneyGraphEdge } from "./JourneyGraphEdge";
+import type { JourneyLedgerHealth } from "./JourneyLedgerHealth";
+import type { JourneyNode } from "./JourneyNode";
+import type { JourneyTrigger } from "./JourneyTrigger";
+import type { JourneyUnmeasuredDepartures } from "./JourneyUnmeasuredDepartures";
+
+/**
+ * The journey graph derived from ledger rows under one filter.
+ */
+export interface JourneyGraph {
+  /**
+   * What the graph was built over.
+   */
+  coverage: JourneyCoverage;
+  /**
+   * Aggregated edges, sorted by `(fromKey, toKey, trigger, outcome)`.
+   */
+  edges: JourneyGraphEdge[];
+  /**
+   * The filter the edge set was narrowed by.
+   */
+  filterEcho: JourneyFilter;
+  /**
+   * Observed nodes, sorted by key.
+   */
+  nodes: JourneyGraphNode[];
+  /**
+   * Unmeasured departures (filtered, withdrawn, rejected frontier with a
+   * valid node, excluded back and URL arrivals) placed at a node key that
+   * is NOT in
+   * `nodes`. No component query can reach such a node, but a graph-wide
+   * question (`dead_ends`, `requires_prior_knowledge`, the whole frontier)
+   * counts them.
+   */
+  offGraphDepartures: JourneyUnmeasuredDepartures;
+  /**
+   * Rows left out as contract violations, live or withdrawn (a withdrawn one
+   * is also counted in `coverage.edgesInvalidated`), sorted.
+   */
+  rejected: JourneyRejectedRow[];
+  /**
+   * Rejected frontier rows counted at TWO node keys (their `nodeKey`
+   * column and their valid node's own key disagree). Per-node counts
+   * include both placements; graph-wide totals subtract this, so a
+   * graph-wide `rejectedFrontier` plus `unplacedRejectedFrontier` is the
+   * number of DISTINCT rejected frontier rows by full content. (`rejected`
+   * lists rows by `(kind, row, reason)`, so two rows differing only in
+   * their node JSON share one entry there but are both counted.)
+   */
+  rejectedFrontierDoublePlaced: number;
+  /**
+   * Affordance or `pop` rows whose real destination is unknown: kept or
+   * trusted-excluded ones with no `toNode` (`to_node_unobserved`), ones
+   * that closed `settle_timeout` or `error` to a DIFFERENT node (that node
+   * may be an intermediate state), and ones that closed `settle_timeout`
+   * on the SAME node (the destination may not have rendered yet). Each
+   * may arrive at any node, so `requires_prior_knowledge` lists no node as
+   * settled while this is non-zero.
+   */
+  unknownDestinationArrivals: number;
+  /**
+   * Distinct rejected frontier rows whose node fails `validate()`.
+   * Nothing in such a row is trusted, its `nodeKey` column included, so it
+   * is placed at NO node: each may be an open affordance anywhere, and
+   * EVERY negative answer counts it (dimension
+   * `unplaced_rejected_frontier`).
+   */
+  unplacedRejectedFrontier: number;
+  /**
+   * Distinct UNTRUSTED edge rows — live or withdrawn rows that fail
+   * [`trusted_edge_row`] (a failed `validate()` or an unparseable
+   * `observedAt`). Nothing in such a row is trusted, its `fromNode` and
+   * trigger included, so it is placed at NO node: it may be a click from
+   * and to anywhere, and EVERY negative answer counts it, component and
+   * graph-wide alike (dimension `unplaced_rejected_rows`). While it is
+   * non-zero, `dead_ends` lists no dead end and `requires_prior_knowledge`
+   * lists no settled node.
+   */
+  unplacedRejectedRows: number;
+}
+/**
+ * One observed vertex.
+ */
+export interface JourneyGraphNode {
+  /**
+   * Excluded affordance / pop rows arriving here from another node.
+   */
+  arrivalDoubt: JourneyArrivalDoubt;
+  /**
+   * Open frontier entries seen at this node, sorted by
+   * `affordanceFingerprint`.
+   */
+  frontier: FrontierEntry[];
+  /**
+   * [`JourneyNode::key`] — the node's identity.
+   */
+  key: string;
+  /**
+   * A representative node for the key (the smallest by its fields when
+   * rows disagree on non-identity detail such as `pageLabel`).
+   */
+  node: JourneyNode;
+  /**
+   * `true` when the node has at least one kept arrival (an edge from a
+   * DIFFERENT node whose `toNode` is this node — a self-loop is not an
+   * arrival), and NONE of them closed `changed` or
+   * `no_change`, whatever its trigger. Only those two outcomes confirm the
+   * node is a real destination: a `settle_timeout` or `error` arrival's
+   * observed node may be an intermediate state (a spinner, an error
+   * render). Such a node is never a settled dead end, nor a settled
+   * requires-prior-knowledge node.
+   */
+  unconfirmedDestination: boolean;
+  /**
+   * Departures from this node the navigation edge set leaves out but that
+   * may still lead somewhere (see [`JourneyUnmeasuredDepartures`]).
+   */
+  unmeasuredDepartures: JourneyUnmeasuredDepartures;
+  /**
+   * How many edges left this node with `outcome: to_node_unobserved` —
+   * actions whose destination was never seen.
+   */
+  unobservedDepartures: number;
+}
+/**
+ * A ledger row that broke the edge-observation contract and was left out of
+ * the graph — reported, never silently dropped.
+ */
+export interface JourneyRejectedRow {
+  /**
+   * Edge or frontier row.
+   */
+  kind: "edge" | "frontier";
+  /**
+   * The contract violation, as `JourneyContractError` renders it (or the
+   * timestamp parse failure).
+   */
+  reason: string;
+  /**
+   * The edge's `id`, or `"<nodeKey> <affordanceFingerprint>"` for a
+   * frontier row.
+   */
+  row: string;
+  /**
+   * How many DISTINCT rows (by full serialized content) this entry stands
+   * for. Two rows that share `(kind, row, reason)` but differ anywhere
+   * else — a live and a withdrawn copy, or two fromNodes under one id —
+   * are one entry here with `rows: 2`. The same full-row identity is the
+   * one `JourneyGraph::unplaced_rejected_rows` and
+   * `unplaced_rejected_frontier` count by, so for edges the `rows` of the
+   * edge entries sum to `unplaced_rejected_rows`.
+   */
+  rows: number;
+}

package/src/generated/JourneyGraphEdge.d.ts

@@ -0,0 +1,45 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { JourneyTrigger } from "./JourneyTrigger";
+
+/**
+ * Every observation of one `(from, to, trigger, outcome)` combination,
+ * aggregated. `to_node_unobserved` rows are not graph edges (they have no
+ * destination); they count on the from-node's `unobservedDepartures`.
+ */
+export interface JourneyGraphEdge {
+  /**
+   * Earliest `observedAt` among them, RFC 3339 UTC.
+   */
+  firstObservedAt: string;
+  /**
+   * `fromNode.key()`.
+   */
+  fromKey: string;
+  /**
+   * Latest `observedAt` among them, RFC 3339 UTC.
+   */
+  lastObservedAt: string;
+  /**
+   * How many ledger rows this edge aggregates (≥ 1).
+   */
+  observations: number;
+  /**
+   * How the edge closed.
+   */
+  outcome:
+    "changed" | "no_change" | "error" | "settle_timeout" | "to_node_unobserved";
+  /**
+   * `toNode.key()`.
+   */
+  toKey: string;
+  /**
+   * The trigger, exactly as recorded — enough to replay the step.
+   */
+  trigger: JourneyTrigger;
+}

package/src/generated/JourneyPriorKnowledge.d.ts

@@ -0,0 +1,112 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { FrontierEntry } from "./FrontierEntry";
+import type { JourneyArrivalDoubt } from "./JourneyArrivalDoubt";
+import type { JourneyCoverage } from "./JourneyCoverage";
+import type { JourneyFilter } from "./JourneyFilter";
+import type { JourneyLedgerHealth } from "./JourneyLedgerHealth";
+import type { JourneyNode } from "./JourneyNode";
+import type { JourneySearchFrontier } from "./JourneySearchFrontier";
+import type { JourneySearchFrontierNode } from "./JourneySearchFrontierNode";
+import type { JourneyUnmeasuredDepartures } from "./JourneyUnmeasuredDepartures";
+
+/**
+ * The answer of [`requires_prior_knowledge`].
+ */
+export interface JourneyPriorKnowledge {
+  /**
+   * The graph's coverage.
+   */
+  coverage: JourneyCoverage;
+  /**
+   * The graph's filter.
+   */
+  filterEcho: JourneyFilter;
+  /**
+   * What the whole graph did not look at. A listed node never rests on an
+   * open frontier (any open entry moves every candidate to `unsettled`);
+   * this block is what the NEGATIVE about the rest — "no other node
+   * requires prior knowledge" — is unknown over unless it is settled.
+   */
+  frontier: JourneySearchFrontier;
+  /**
+   * Nodes that require prior knowledge, settled: they qualify, nothing
+   * the graph left out could reach them by a click or a back button, no
+   * affordance anywhere is still unexplored, and the ledger is `writing`.
+   * Sorted by key.
+   */
+  nodes: JourneyPriorKnowledgeNode[];
+  /**
+   * Nodes that qualify on their kept arrivals but cannot be settled, with
+   * the causes that could still reach them. Sorted by key.
+   */
+  unsettled: JourneyPriorKnowledgeUnsettledNode[];
+}
+/**
+ * A node users only ever arrived at without clicking anything.
+ */
+export interface JourneyPriorKnowledgeNode {
+  /**
+   * Observed arrivals per navigation trigger (`initial`, `push`,
+   * `replace`, `hash` only — by definition).
+   */
+  arrivals: {
+    [k: string]: number;
+  };
+  /**
+   * The node.
+   */
+  nodeKey: string;
+}
+/**
+ * A node that qualifies on its KEPT arrivals, but that some row the graph
+ * left out could still reach by a click or a back button — so whether it
+ * requires prior knowledge is unknown.
+ */
+export interface JourneyPriorKnowledgeUnsettledNode {
+  /**
+   * Excluded (filtered / withdrawn) affordance or pop arrivals into it.
+   */
+  arrivalDoubt: JourneyArrivalDoubt;
+  /**
+   * Its kept URL-trigger arrivals, as in [`JourneyPriorKnowledgeNode`].
+   */
+  arrivals: {
+    [k: string]: number;
+  };
+  /**
+   * The ledger is not `writing`: a click into this node may simply have
+   * failed to be recorded.
+   */
+  ledgerNotWriting: boolean;
+  /**
+   * The node.
+   */
+  nodeKey: string;
+  /**
+   * Open frontier entries across the WHOLE graph — listable ones, rejected
+   * ones placed at a node, and unplaced rejected ones, each row once. An
+   * affordance nobody activated anywhere may be the link into this node.
+   */
+  openFrontierEntries: number;
+  /**
+   * No observed arrival at this node closed `changed` or `no_change`
+   * ([`JourneyGraphNode::unconfirmed_destination`]): it may be an
+   * intermediate state, not a page a URL leads to.
+   */
+  unconfirmedDestination: boolean;
+  /**
+   * [`JourneyGraph::unknown_destination_arrivals`] — any of them may
+   * arrive here.
+   */
+  unknownDestinationArrivals: number;
+  /**
+   * [`JourneyGraph::unplaced_rejected_rows`] — any of them may arrive here.
+   */
+  unplacedRejectedRows: number;
+}

package/src/generated/JourneyReachable.d.ts

@@ -0,0 +1,64 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { FrontierEntry } from "./FrontierEntry";
+import type { JourneyCoverage } from "./JourneyCoverage";
+import type { JourneyFilter } from "./JourneyFilter";
+import type { JourneyLedgerHealth } from "./JourneyLedgerHealth";
+import type { JourneyNode } from "./JourneyNode";
+import type { JourneySearchFrontier } from "./JourneySearchFrontier";
+import type { JourneySearchFrontierNode } from "./JourneySearchFrontierNode";
+import type { JourneyUnmeasuredDepartures } from "./JourneyUnmeasuredDepartures";
+
+/**
+ * The answer of [`reachable_from`].
+ */
+export interface JourneyReachable {
+  /**
+   * The graph's coverage.
+   */
+  coverage: JourneyCoverage;
+  /**
+   * The graph's filter.
+   */
+  filterEcho: JourneyFilter;
+  /**
+   * The start node's key.
+   */
+  fromKey: string;
+  /**
+   * Whether the start node was observed at all. `false` means the
+   * question was asked about a node the ledger has never seen — the
+   * caller answers `unknown` (`no_observations`), never "reaches nothing".
+   */
+  fromObserved: boolean;
+  /**
+   * What the searched component (exactly the `reachable` nodes) did not
+   * look at. Unsettled ⇒ "X is not reachable" is unknown.
+   */
+  frontier: JourneySearchFrontier;
+  /**
+   * Every node reachable from the start, INCLUDING the start at 0 steps
+   * (empty when `fromObserved` is false), sorted by key.
+   */
+  reachable: JourneyReachedNode[];
+}
+/**
+ * A node reached, and its BFS distance.
+ */
+export interface JourneyReachedNode {
+  /**
+   * The node.
+   */
+  nodeKey: string;
+  /**
+   * Shortest OBSERVED number of navigation edges from the start (0 = the
+   * start) — an upper bound on the true distance while the frontier is
+   * unsettled.
+   */
+  steps: number;
+}

package/src/generated/JourneySearchFrontier.d.ts

@@ -0,0 +1,59 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { FrontierEntry } from "./FrontierEntry";
+import type { JourneyNode } from "./JourneyNode";
+import type { JourneySearchFrontierNode } from "./JourneySearchFrontierNode";
+import type { JourneyUnmeasuredDepartures } from "./JourneyUnmeasuredDepartures";
+
+/**
+ * What the searched part of the graph did NOT look at. Empty
+ * ([`Self::is_settled`]) means a negative answer over that part is a real
+ * negative; otherwise it is unknown.
+ */
+export interface JourneySearchFrontier {
+  /**
+   * Open frontier entries per reason — every reason present, zeros
+   * included.
+   */
+  byReason: {
+    [k: string]: number;
+  };
+  /**
+   * Nodes with open frontier entries, unobserved departures or unmeasured
+   * departures, sorted by key.
+   */
+  nodes: JourneySearchFrontierNode[];
+  /**
+   * The off-graph part included in `unmeasuredDepartures` (all zero for a
+   * question about one component).
+   */
+  offGraphDepartures: JourneyUnmeasuredDepartures;
+  /**
+   * Open frontier entries across those nodes.
+   */
+  openEntries: number;
+  /**
+   * Unmeasured departures across those nodes, plus — for a graph-wide
+   * question — `offGraphDepartures`.
+   */
+  unmeasuredDepartures: JourneyUnmeasuredDepartures;
+  /**
+   * Unobserved departures across those nodes.
+   */
+  unobservedDepartures: number;
+  /**
+   * Rejected frontier rows that could not be placed at any node (counted
+   * by every question).
+   */
+  unplacedRejectedFrontier: number;
+  /**
+   * Untrusted edge rows that could not be placed at any node (counted by
+   * every question).
+   */
+  unplacedRejectedRows: number;
+}

package/src/generated/JourneySearchFrontierNode.d.ts

@@ -0,0 +1,37 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { FrontierEntry } from "./FrontierEntry";
+import type { JourneyNode } from "./JourneyNode";
+import type { JourneyUnmeasuredDepartures } from "./JourneyUnmeasuredDepartures";
+
+/**
+ * One node, inside a query's searched component, that was not fully looked
+ * at.
+ */
+export interface JourneySearchFrontierNode {
+  /**
+   * The node.
+   */
+  nodeKey: string;
+  /**
+   * Its open frontier entries, grouped by reason (only reasons present),
+   * each list sorted by `affordanceFingerprint` — the affordances that
+   * would have to be explored to settle the question.
+   */
+  openByReason: {
+    [k: string]: FrontierEntry[];
+  };
+  /**
+   * Departures from it the navigation edge set left out.
+   */
+  unmeasuredDepartures: JourneyUnmeasuredDepartures;
+  /**
+   * Departures from it whose destination was never observed.
+   */
+  unobservedDepartures: number;
+}

package/src/generated/JourneySteps.d.ts

@@ -0,0 +1,65 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+import type { FrontierEntry } from "./FrontierEntry";
+import type { JourneyCoverage } from "./JourneyCoverage";
+import type { JourneyFilter } from "./JourneyFilter";
+import type { JourneyGraphEdge } from "./JourneyGraphEdge";
+import type { JourneyLedgerHealth } from "./JourneyLedgerHealth";
+import type { JourneyNode } from "./JourneyNode";
+import type { JourneySearchFrontier } from "./JourneySearchFrontier";
+import type { JourneySearchFrontierNode } from "./JourneySearchFrontierNode";
+import type { JourneyTrigger } from "./JourneyTrigger";
+import type { JourneyUnmeasuredDepartures } from "./JourneyUnmeasuredDepartures";
+
+/**
+ * The answer of [`steps_to`].
+ */
+export interface JourneySteps {
+  /**
+   * The graph's coverage.
+   */
+  coverage: JourneyCoverage;
+  /**
+   * The graph's filter.
+   */
+  filterEcho: JourneyFilter;
+  /**
+   * The start node's key.
+   */
+  fromKey: string;
+  /**
+   * Whether the start node was observed.
+   */
+  fromObserved: boolean;
+  /**
+   * What the component reachable from the start did not look at.
+   */
+  frontier: JourneySearchFrontier;
+  /**
+   * The edges of one shortest path, in order (empty when `steps` is null
+   * or 0). Among equally short paths, the one whose next node key is
+   * byte-wise smallest at every step; between parallel edges, the
+   * smallest edge in graph order.
+   */
+  path: JourneyGraphEdge[];
+  /**
+   * Shortest OBSERVED number of navigation edges from start to target — an
+   * upper bound on the true distance while the frontier is unsettled;
+   * `null` = no observed path (which is a negative only when `frontier` is settled and
+   * both endpoints were observed).
+   */
+  steps?: number | null;
+  /**
+   * The target node's key.
+   */
+  toKey: string;
+  /**
+   * Whether the target node was observed.
+   */
+  toObserved: boolean;
+}

package/src/generated/JourneyUnmeasuredDepartures.d.ts

@@ -0,0 +1,84 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * Departures from one node that the NAVIGATION edge set (affordance +
+ * `changed`) leaves out, yet that may still lead somewhere — so a negative
+ * answer over a component containing the node stays `unknown`, never
+ * `absent`. The navigation counters count only `affordance`-triggered rows
+ * (a typed URL is not a way the app offers); excluded back-button (`pop`)
+ * rows have their own counter, [`Self::excluded_back_arrivals`]. A filtered
+ * or withdrawn click or back that closed `no_change`, or `error` on its own
+ * node, is never counted: that exclusion is a genuine negative (a URL-trigger
+ * row never is one). (A REJECTED row is not counted here at all: nothing in it is
+ * trusted, so it is placed at no node — see
+ * [`JourneyGraph::unplaced_rejected_rows`].) Each counter is its own
+ * `coverage.unmeasured` dimension — see [`JourneySearchFrontier::unmeasured`]
+ * for the dimension names and codes.
+ */
+export interface JourneyUnmeasuredDepartures {
+  /**
+   * `error` edges to a DIFFERENT node: the action errored yet the
+   * configuration moved. Dimension `errored_departures`.
+   */
+  errored: number;
+  /**
+   * Back-button (`pop`) rows from this node that are not a kept, changed
+   * exit: valid `pop` rows the filter excluded or that were withdrawn
+   * (unless a genuine negative: `no_change`, or `error` on its own node),
+   * kept `pop` edges to ANOTHER node whose outcome is `error` or
+   * `settle_timeout`, and kept `pop` self-loops that closed
+   * `settle_timeout` (the same rules as an affordance edge's). A REJECTED pop row is not here — nothing in a rejected row
+   * is trusted, so it counts in `JourneyGraph::unplaced_rejected_rows`.
+   * Not a navigation
+   * departure, so a question about one component ignores it; the
+   * graph-wide questions it can change — `dead_ends`' `backOnly`,
+   * `requires_prior_knowledge`, the whole frontier — count it. Dimension
+   * `excluded_back_arrivals`.
+   */
+  excludedBackArrivals: number;
+  /**
+   * Valid URL-trigger rows (`initial` / `push` / `replace` / `hash`) from
+   * this node that the filter excluded or that were withdrawn, WHATEVER
+   * their outcome (a URL row is an arrival, never a genuine negative). A typed URL is not a navigation departure, so a question
+   * about one component ignores it; but it is an ARRIVAL that decides
+   * `requires_prior_knowledge`, and it may reveal a node no kept row
+   * shows, so the graph-wide questions (`requires_prior_knowledge`,
+   * `dead_ends`, the whole frontier) count it. Dimension
+   * `excluded_url_arrivals`.
+   */
+  excludedUrlArrivals: number;
+  /**
+   * Live, valid affordance rows the request's filter (`since` /
+   * `appVersion` / `runKind`) excluded, unless they are a genuine negative
+   * (`no_change`, or `error` on their own node). Dimension
+   * `filtered_departures`.
+   */
+  filteredOut: number;
+  /**
+   * Frontier rows at this node that failed `validate()` — treated as OPEN
+   * entries the read cannot list. A row whose `nodeKey` column disagrees
+   * with its `node` is counted at BOTH keys (the column's, and the valid
+   * node's), since either may be the true one. Dimension
+   * `rejected_frontier`.
+   */
+  rejectedFrontier: number;
+  /**
+   * Affordance edges that closed `settle_timeout` — to a DIFFERENT node
+   * (the destination may be an intermediate render), or to the SAME node
+   * (the destination may not have rendered before the snapshot). Not a
+   * navigation step, but not a negative either. Dimension
+   * `settle_timeout_departures`.
+   */
+  settleTimeout: number;
+  /**
+   * Withdrawn affordance rows (`invalidatedAt` set) that pass `validate()`,
+   * unless they are a genuine negative (`no_change`, or `error` on their
+   * own node). Dimension `withdrawn_departures`.
+   */
+  withdrawn: number;
+}

package/src/generated/MappingRow.d.ts

@@ -0,0 +1,23 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated.
+ * DO NOT MODIFY IT BY HAND. Regenerate with
+ * `qontinui-runner/src-tauri/scripts/generate_types.sh`.
+ */
+
+/**
+ * One row of an interface mapping.
+ */
+export interface MappingRow {
+  /**
+   * The business rule or requirement (`spec_ref`) the row implements.
+   */
+  rule_ref?: string | null;
+  source_field: string;
+  target_field: string;
+  /**
+   * The transformation applied, in prose or a short expression.
+   */
+  transform?: string | null;
+  [k: string]: unknown;
+}