@kortexya/reasoninglayer 1.27.0 → 1.28.0

package/dist/index.d.ts

@@ -130,7 +130,7 @@ type JsonValue$1 = string | number | boolean | null | JsonValue$1[] | object;
  * This is the single source of truth for the version constant.
  * The `scripts/release.sh` script updates this value alongside `package.json`.
  */
-declare const SDK_VERSION = "1.27.0";
+declare const SDK_VERSION = "1.28.0";
 /**
  * Authentication mode for the SDK.
  *
@@ -3187,28 +3187,110 @@ interface BulkAddRulesResponse$1 {
  * Creates multiple terms in a single operation for efficiency.
  * This is much faster than creating terms one by one when you have many terms.
  *
+ * The batch is ALL-OR-NOTHING: one refused entry refuses the whole batch and
+ * nothing is written, and the refusal names EVERY refused row (#262).
+ *
+ * `dry_run` (#262) runs every check the real write runs — declarations,
+ * coreference, events — and writes nothing. A clean dry run answers `200`
+ * with the ids the entries WOULD carry; a refused one answers the same
+ * `errors[]` body the real write answers with.
+ *
  * # Tenant Context
  * The tenant is determined from the `X-Tenant-Id` header.
  */
 interface BulkAddTermsRequest$1 {
-    /** List of terms to create */
-    terms: CreateTermRequest$1[];
+    /** Run every check the write runs, then write nothing. Default `false`. */
+    dry_run?: boolean;
+    /**
+     * Write the entries this batch did not refuse, instead of refusing the
+     * whole batch for one bad row. Default `false` — the all-or-nothing
+     * verdict stays the default (#271).
+     *
+     * A real import holding one bad record had to be resent minus that record:
+     * a second full call, a second full round of constraint evaluation, and a
+     * window in which a survivor's reference target can be deleted between the
+     * two. The engine already names every bad entry by index in one pass, so
+     * it already knows which ones were fine.
+     *
+     * With `partial: true` the response is `201` when anything was written and
+     * `422` when every row was refused; `term_ids` carries one id per ACCEPTED
+     * row in request order, and `errors[]` names the refused ones by their
+     * REQUEST index, so the positions reconstruct.
+     *
+     * ⚠️ Two failures stay batch-wide whatever this says, because neither can
+     * be attributed to a row: the end-of-batch constraint propagation
+     * (`409`, one verdict for the whole batch) and a persistence failure,
+     * which reverts what the batch inserted (#239).
+     */
+    partial?: boolean;
+    /**
+     * List of terms to create. Each entry names its sort by `sort_id` or by
+     * `sort_name` (#278).
+     */
+    terms: CreateTermInput$1[];
 }
 /** Response from bulk term addition */
 interface BulkAddTermsResponse$1 {
+    /**
+     * On a DRY RUN: the existing entities this batch would have merged into
+     * through a `@key` coreference (#238), in request order of the entries
+     * that coreferenced. These ids name terms that already exist, so they
+     * survive the rollback and a caller may hold them.
+     *
+     * Absent on a real write, where every effective id is in
+     * [`Self::term_ids`] already.
+     */
+    coreferenced_term_ids?: string[] | null;
+    /**
+     * `true` when nothing was written because the request carried
+     * `dry_run: true` — every check ran, and nothing the checks decided was
+     * written (#262).
+     */
+    dry_run: boolean;
+    /**
+     * Every row this batch refused, in request order, each naming its position
+     * in the request's `terms` array (#271).
+     *
+     * Present only under `partial: true`, where a refusal no longer refuses
+     * the batch. Without it a refused row answers `422` with the same list in
+     * the error body, and nothing is written.
+     */
+    errors?: BulkRowRefusalDto[];
     /**
      * Processing time in milliseconds
      * @min 0
      */
     processing_time_ms: number;
     /**
-     * Effective term id per request position: the created id, or the EXISTING
+     * How many rows were refused — `errors.len()`, carried so a client can
+     * test one number rather than the emptiness of a list.
+     * @min 0
+     */
+    refused?: number;
+    /**
+     * Effective term id per WRITTEN entry: the created id, or the EXISTING
      * entity's id when the entry coreferenced into it through a `@key` feature
      * (#238). Always in request order.
+     *
+     * One id per request position on an all-or-nothing batch, which is the
+     * default. Under `partial: true` it carries one id per ACCEPTED row, and
+     * [`Self::errors`] names the refused positions — together they reconstruct
+     * the request array (#271).
+     *
+     * ABSENT on a dry run (#268). A dry run rolls the store back, so an id it
+     * minted for a fresh entry names nothing and can never name anything — a
+     * second, real POST of the same body mints a different one. Answering the
+     * vector anyway handed a caller dangling references in the very positions
+     * this field documents as storable. The two positions whose id IS durable
+     * — an entry that coreferenced into an existing entity — are reported
+     * separately in [`Self::coreferenced_term_ids`], because a vector that is
+     * truthful in some positions and fabricated in others is exactly the shape
+     * that got those ids stored.
      */
-    term_ids: string[];
+    term_ids?: string[] | null;
     /**
-     * Number of terms created
+     * Number of terms created (on a dry run: the number the batch WOULD
+     * create, fresh entries plus coreferenced ones)
      * @min 0
      */
     terms_added: number;
@@ -3461,6 +3543,29 @@ interface BulkReviewResponse {
      */
     success_count: number;
 }
+/**
+ * One refused row of a bulk write (#262).
+ *
+ * The index is the row's position in the REQUEST array, so a client maps the
+ * refusal back to the exact row it sent — not to a store id the caller never
+ * named. `feature` is absent when the refusal is about the row as a whole
+ * (a closed-world shape, a multiplicity bound, a ⊥ meet); the message always
+ * carries it in prose.
+ * `Deserialize` and `ToSchema` because a refused row also appears in a
+ * SUCCESS body since #271: `partial: true` writes the rows it did not refuse
+ * and reports the rest here, so this type crosses the wire in both directions.
+ */
+interface BulkRowRefusalDto {
+    /** The feature the refusal names, when it names one. */
+    feature?: string | null;
+    /**
+     * The row's position in the request's `terms` array, zero-based.
+     * @min 0
+     */
+    index: number;
+    /** The refusal in words — the same message a single-term write answers with. */
+    message: string;
+}
 /** Request to set multiple sort similarities in bulk */
 interface BulkSetSimilaritiesRequest$1 {
     /** List of similarity relations to set */
@@ -3541,7 +3646,7 @@ interface BulkSortError$1 {
  * re-classification. This enum is what a client reads instead; the message
  * stays human-facing.
  */
-type BulkSortErrorKind$1 = "reserved_name" | "unreadable_name" | "unsatisfiable_declaration" | "unresolved_parent" | "unbound_relation";
+type BulkSortErrorKind$1 = "reserved_name" | "unreadable_name" | "unsatisfiable_declaration" | "unknown_type_hint" | "unresolved_parent" | "unbound_relation";
 /** Request to run ECE calibration. */
 interface CalibrateRequest$1 {
     /** Extraction predictions with confidence and correctness. */
@@ -3689,6 +3794,17 @@ interface CaptureSnapshotRequest$1 {
     max_entries?: number | null;
     request_path_pattern: string;
 }
+/**
+ * Where a feature's multiplicity bound came from, and therefore whether a
+ * write may be refused for breaking it (#258).
+ *
+ * The wire twin of `osfkb_domain::types::sort::CardinalityOrigin`. It exists
+ * on this DTO because a READ renders `min_count`/`max_count`, and the ordinary
+ * way to amend a sort is GET → edit → POST: without the origin beside the
+ * bound, that round trip would promote every bound the EXTRACTION pipeline
+ * inferred into a declared one and start refusing the ingestion that wrote it.
+ */
+type CardinalityOriginDto$1 = "declared" | "inferred";
 /**
  * Schema-bearing mirror of the domain [`CatalogEntry`]: the response DTO.
  *
@@ -3738,6 +3854,20 @@ interface CatalogEntryDoc {
     full: string;
     /** Stable snake_case id, e.g. `"aggregate"`, `"insert_bulk"`. */
     id: string;
+    /**
+     * Whether this statement writes the store: `"never"`, `"always"`, or
+     * `"depends"` when only the authored arguments can decide (an inline-write
+     * `MATCH`, an `IF` whose branch writes, the effectful `CALL "action" WITH`
+     * form).
+     *
+     * [`Self::category`] cannot answer this: `CHAIN` and `RELEASE
+     * RESIDUATIONS` are `Control` and both write, while `MATCH` is `Read` and
+     * writes whenever it carries an inline clause. A client reads this field
+     * instead of keeping its own table of which process-control statements
+     * write, and resolves `"depends"` through `POST /api/v1/osfql/preview`,
+     * whose per-statement `mutates` is a concrete boolean (#266).
+     */
+    mutates: string;
     /**
      * The grounding ingredients the authoring stage must supply to write this
      * statement (`Sort`, `Features`, `Pattern`, `TermId`, …).
@@ -4933,7 +5063,7 @@ interface ClusteredObservationDto$1 {
     y: number;
 }
 /** A formula found coextensive with a sort's definition, and its evidence. */
-interface CoextensiveDefinitionDto {
+interface CoextensiveDefinitionDto$1 {
     /** The alternative formula, rendered. */
     definition: string;
     /**
@@ -7318,6 +7448,42 @@ interface CreateTenantResponse$1 {
     /** The provisioned tenant UUID (echoes the request or the generated value). */
     tenant_id: string;
 }
+/**
+ * A term write that names its sort by NAME rather than by id (#278).
+ *
+ * # Architectural context
+ *
+ * `POST /api/v1/inference/facts` and every OSFQL write take a sort name; the
+ * term routes took only a UUID, so a caller holding names had to resolve every
+ * sort first — on the bulk route, the one place the extra round trips cost
+ * most, because it exists for volume.
+ *
+ * A separate struct rather than an optional field on [`CreateTermRequest`]:
+ * both are `deny_unknown_fields`, so the untagged pair is decidable — a body
+ * carrying `sort_id` cannot match this one and a body carrying `sort_name`
+ * cannot match that one — and exactly one of the two is stated, which is the
+ * #209 rule that one slot has one claimant.
+ */
+interface CreateTermByNameRequest$1 {
+    /** Features map */
+    features: Partial<Record<string, ValueDto$1>>;
+    /**
+     * Optional client-supplied TermId, read exactly as
+     * [`CreateTermRequest::id`].
+     * @format uuid
+     */
+    id?: string | null;
+    /**
+     * Owner ID
+     * @format uuid
+     */
+    owner_id: string;
+    /**
+     * The sort's name, resolved against the tenant's lattice. An unknown name
+     * refuses the write; it never mints a sort.
+     */
+    sort_name: string;
+}
 /** Request to create a term within a specific collection */
 interface CreateTermInCollectionRequest$1 {
     /**
@@ -7343,6 +7509,14 @@ interface CreateTermInCollectionRequest$1 {
      */
     tenant_id: string;
 }
+/**
+ * A term write, naming its sort by id or by name (#278).
+ *
+ * `CreateTermRequest` is declared FIRST so the by-id spelling is tried first;
+ * variant order is load-bearing in an untagged enum (#232), even though these
+ * two are made mutually exclusive by `deny_unknown_fields`.
+ */
+type CreateTermInput$1 = CreateTermRequest$1 | CreateTermByNameRequest$1;
 /**
  * Request to create a term
  *
@@ -10496,8 +10670,15 @@ interface EvaluateFunctionRequest$1 {
      * @default 100
      */
     max_depth?: number;
-    /** @format uuid */
-    tenant_id: string;
+    /**
+     * OPTIONAL, and ignored when it agrees with `X-Tenant-Id`; a contradicting
+     * value is refused with `function_tenant_mismatch`. Identical contract to
+     * [`RegisterFunctionRequest::tenant_id`] — evaluate carried the same
+     * required-and-ignored field, and fixing only register would have moved
+     * the inconsistency one route over (#268).
+     * @format uuid
+     */
+    tenant_id?: string | null;
 }
 /** Response from function evaluation */
 type EvaluateFunctionResponse$1 = {
@@ -11604,6 +11785,19 @@ type FeatureConstraintDto = {
 interface FeatureDescriptorDto$1 {
     /** Custom OWL annotations for this feature (e.g., isIdentifier, unit, enumValues) */
     annotations?: Partial<Record<string, string>>;
+    /**
+     * Where the bound above came from — `"declared"` or `"inferred"` (#258).
+     *
+     * A bound written through this door without the field is DECLARED, and the
+     * write path refuses a term that breaks it. `"inferred"` records a bound
+     * read out of an extracted axiom: it is carried, exported and diffed, and
+     * it refuses nothing.
+     *
+     * A READ answers it beside the bound whenever the stored descriptor
+     * records one, so the ordinary GET → edit → POST amendment of an extracted
+     * sort sends the origin back unchanged and the bound keeps its standing.
+     */
+    cardinality_origin?: null | CardinalityOriginDto$1;
     /**
      * Optional constraint on the feature value. Defaults to `None`
      * when absent so callers needn't send an explicit null.
@@ -11636,9 +11830,27 @@ interface FeatureDescriptorDto$1 {
      */
     expected_sort_name?: string | null;
     /**
-     * Primitive type hint for LLM extraction (e.g., "DateTime", "Integer", "String", "Real")
-     * Used to tell the LLM what type of value to extract for this feature.
-     * If `expected_sort` is set, it takes precedence over this hint.
+     * The value SHAPE this feature admits — one word from the engine's one
+     * type-hint vocabulary.
+     *
+     * Accepted words: `Integer`, `BigInteger`, `Real`, `String`, `Uri`,
+     * `Boolean`, `Date`, `DateTime`, `List`, `Set`, `Fuzzy`, `FuzzyScalar`,
+     * `FuzzyNumber`, `SortId`, `ExternalRef`, `Geometry`, `Measurement` — plus
+     * the structured kinds `vector(<dim>)`, `timeseries(<scalar>)`, `geotime`
+     * and `mediareference(<kind>)`. Every common alias is read too, case
+     * insensitively (`int`, `bigint`, `double`, `text`, `bool`, `timestamp`,
+     * `url`, …), so an OSFQL `DEFINE person (name: string)` and this field
+     * declare the same thing.
+     *
+     * A READ always answers in the canonical spelling above, whatever the
+     * caller wrote (#264). A word outside the vocabulary is refused with 422 at
+     * declaration rather than silently enforced against every write forever.
+     *
+     * A feature whose value is another TERM declares `expected_sort` (or
+     * `expected_sort_name`), which is the range; `expected_sort` takes
+     * precedence over this hint.
+     *
+     * The vocabulary itself lives in `crates/domain/src/types/type_hint.rs`.
      */
     expected_type_hint?: string | null;
     /**
@@ -11662,12 +11874,22 @@ interface FeatureDescriptorDto$1 {
      */
     max_count?: number | null;
     /**
-     * Declared multiplicity bounds, when a cardinality constraint was extracted.
+     * Declared multiplicity bounds, when a cardinality constraint was extracted
+     * or declared.
      *
      * `required` is only a boolean — it cannot express "exactly two" or "at most
      * three". These surface the real bound so a caller (and the extraction
      * benchmark) can see WHICH cardinality was asserted, not merely that the
      * feature is present.
+     *
+     * Both have an OSFQL spelling since #269: `@card(min)` and
+     * `@card(min, max)`, with `*` as the explicit unbounded maximum. So a sort
+     * declared through either door reads back identically, and a schema export
+     * of a JSON-authored sort is DDL that declares the same thing.
+     *
+     * ⚠️ A non-zero `min_count` IS [`Self::required`] — see that field. A
+     * declaration stating both with different meanings is refused, not
+     * corrected.
      * @format int32
      * @min 0
      */
@@ -11681,6 +11903,22 @@ interface FeatureDescriptorDto$1 {
      * declaration — it says what the value's sort must be, not that the
      * feature must be present — so the minimal relational descriptor is
      * `{"name": "issued_to", "expected_sort_name": "Client"}`.
+     *
+     * ⚠️ THE SAME STATEMENT AS `min_count >= 1` (#269). "Must be present" and
+     * "must hold at least one value" are one fact at two resolutions, and the
+     * engine keeps them consistent in both directions: `required: true` with
+     * no `min_count` floors the minimum at 1, and **`min_count >= 1` derives
+     * `required: true` whatever this field says**. The second is the documented
+     * implication — and it cannot be refused instead, because this field is
+     * `#[serde(default)]`, so an omitted `required` and an explicit
+     * `"required": false` are indistinguishable here.
+     *
+     * `{"required": true, "min_count": 0}` IS refused, with a `400`: that pair
+     * can only come from the wire, and it used to store `min_count: 1` in
+     * silence. See [`FeatureDescriptorDto::cardinality_contradiction`].
+     *
+     * A consequence: there is no way to say "optional, but if present then at
+     * least two". That needs a bound the descriptor does not carry.
      */
     required?: boolean;
 }
@@ -11716,6 +11954,7 @@ type FeatureInputValueDto$1 = {
     /**
      * Input for creating/referencing a term (TRUE HOMOICONICITY). Either:
      * - {term_id: UUID} to reference an existing term, OR
+     * - {designator: {sort_name, features}} to address an existing term through its sort's @key, OR
      * - {sort_id: UUID, features: {...}} to define inline with sort ID, OR
      * - {sort_name: String, features: {...}} to define inline with sort name (resolved server-side)
      * An inline antecedent may carry binding: "?C" to name its own identity.
@@ -11769,6 +12008,7 @@ type FeatureTypeDto$1 = "string" | "integer" | "real" | "boolean" | "reference"
  * - number (f64)
  * - boolean
  * - null
+ * - a whole PsiTermDto, for a reference the read surface hides (a negated antecedent's probed pattern)
  * - array of FeatureValueDto
  */
 type FeatureValueDto$1 = {
@@ -11783,11 +12023,12 @@ type FeatureValueDto$1 = {
      * - number (f64)
      * - boolean
      * - null
+     * - a whole PsiTermDto, for a reference the read surface hides (a negated antecedent's probed pattern)
      * - array of FeatureValueDto
      */
     literal: FeatureValueDto$1;
     term_id: string;
-} | string | number | boolean | null | FeatureValueDto$1[];
+} | PsiTermDto$1 | string | number | boolean | null | FeatureValueDto$1[];
 /** Request to finalize a live oversight session. */
 interface FinalizeSessionRequest {
     /** Optional execution log (for full provenance) */
@@ -11815,16 +12056,19 @@ interface FindBySortRequest$1 {
      */
     filter?: Partial<Record<string, string>> | null;
     /**
-     * Answer with the rule-DERIVED shadows too (#249).
+     * Answer with the rule-DERIVED conclusions too (#249, #261).
+     *
+     * A rule's conclusion is a fresh Ψ-term of the conclusion's sort. A
+     * conclusion of the browsed sort ITSELF is ALWAYS answered, whatever this
+     * flag says. When the conclusion's sort is a proper SUBSORT of the browsed
+     * one — the `confirmed_order < sales_order` shape — the conclusion is a
+     * lattice member of the browsed sort, and the default browse hides it so
+     * two orders read as two rows, not four; `true` reveals it. This is the
+     * request-level twin of OSFQL `MATCH … INCLUDING DERIVED`, and every
+     * returned term reports `origin` (and `derived_by`) either way.
      *
-     * A rule's conclusion is a fresh Ψ-term of the conclusion's sort. When
-     * that sort is a proper SUBSORT of the browsed one — the
-     * `confirmed_order < sales_order` shape — the conclusion is a lattice
-     * member of the browsed sort, and the default browse hides it so two
-     * orders read as two rows, not four. A conclusion of the browsed sort
-     * ITSELF is always answered. This is the request-level twin of OSFQL
-     * `MATCH … INCLUDING DERIVED`; every returned term reports `origin`
-     * either way.
+     * The conclusions come from the tenant's RESIDENT store, which is where a
+     * chain leaves them; the route doc says what that promises.
      */
     include_derived?: boolean;
     /**
@@ -11835,6 +12079,15 @@ interface FindBySortRequest$1 {
      * @min 0
      */
     limit?: number | null;
+    /**
+     * Zero-based index of the first term to return (default `0`). Mirrors
+     * `TermListQuery.offset` on `GET /api/v1/terms` and pages the SAME
+     * ordering: the result is ordered by term id before it is cut, so page 2
+     * neither repeats nor skips a row of page 1. Honoured with or without
+     * `limit` (#261).
+     * @min 0
+     */
+    offset?: number | null;
     /**
      * Sort ID to search for (takes precedence over sort_name)
      * @format uuid
@@ -12244,6 +12497,31 @@ interface ForwardChainRequest$1 {
      * AUGMENTS the base — it never replaces it (#218).
      */
     initial_facts?: TermInputDto$1[];
+    /**
+     * KEEP the run's derivations in the tenant's store instead of rolling
+     * them back, so a later `MATCH` reads them — the materialise-then-`MATCH`
+     * shape a recursive rule needs, because a fresh backward chain drops the
+     * deepest hop.
+     *
+     * Default: `false`, and "ephemeral" means ROLLED BACK, not merely
+     * unwritten (#218): the handler removes every wrapper and inner copy the
+     * run created before it answers. So a default run reports
+     * `derived_count: N` and leaves the store exactly as it found it — **this
+     * route is not a repair door**. To re-materialise a tenant, use OSFQL
+     * `CHAIN;` or `POST /api/v1/admin/derived-facts/rebuild/{tenant_id}`
+     * (#270).
+     *
+     * ⚠️ NOT durable, and it never was in any useful sense (#273). Inference
+     * output is re-materialised, never stored — the same contract
+     * `handlers::osfql_persist` documents for OSFQL `CHAIN`. The flag was
+     * called `keep_derived` and did write to Postgres, but it wrote only
+     * the `meta.clause` WRAPPER of each conclusion and never the inner ground
+     * copy every reader returns, so the conclusion did not survive a restart
+     * and the durable store kept a row referencing an id no row backed. The
+     * write is gone; what the flag always really did — keep the derivations
+     * resident — is what it says now.
+     */
+    keep_derived?: boolean;
     /**
      * Maximum facts to derive
      * @min 0
@@ -12257,12 +12535,34 @@ interface ForwardChainRequest$1 {
      */
     max_iterations?: number;
     /**
-     * TRUE HOMOICONICITY: Persist derived facts to PostgreSQL and add to homoiconic_rules.
-     * When true, derived facts become permanent facts/rules that survive server restart
-     * and are available for backward chaining.
-     * Default: false (derived facts are ephemeral, returned but not persisted)
+     * A server-side deadline for this derivation, in milliseconds.
+     *
+     * The chainer checks it cooperatively — at every fixpoint-iteration
+     * boundary, at every rule application, and inside each rule's own
+     * candidate loop — and the route answers `504` when it passes. Clamped by
+     * `OSFKB_FC_TIMEOUT_SECS`.
+     *
+     * Omitted = the derivation backstop (`OSFKB_FC_TIMEOUT_SECS`, default
+     * 300 s). That is a SEPARATE knob from the safe-method backstop
+     * (`OSFKB_REQUEST_TIMEOUT_SECS`, default 60 s): a full materialisation
+     * over a large tenant is legitimately longer than a `GET` handler future.
+     * The deadline is ON by default because this route is a POST, which the
+     * request-deadline middleware never bounds, and one unbounded derivation
+     * holds the tenant's hierarchy guard and term-store write guard for its
+     * whole run.
+     *
+     * `0` is the explicit opt-out: no deadline at all, for a materialisation
+     * longer than the backstop.
+     *
+     * A deadline does not change what the run keeps — `keep_derived` stays
+     * the single switch (#218). A truncated `keep_derived: true` run keeps
+     * the partial derivation it reached, so a re-run continues from it; a
+     * truncated `keep_derived: false` run is rolled back and keeps nothing.
+     * The `504` body says which happened.
+     * @format int64
+     * @min 0
      */
-    persist_derived?: boolean;
+    timeout_ms?: number | null;
 }
 /** Response for forward chaining. */
 interface ForwardChainResponse$1 {
@@ -12279,16 +12579,22 @@ interface ForwardChainResponse$1 {
      */
     iterations: number;
     /**
-     * Materialization time in milliseconds
+     * Derivations this run KEPT in the tenant's store — non-zero only when
+     * the request carried `keep_derived: true`, since a default run rolls its
+     * output back (#218).
+     *
+     * Counts `meta.clause` wrappers, which is one per conclusion. It counted
+     * rows written to Postgres until #273, when that write was removed: it
+     * stored only the wrapper and never the inner ground copy a reader
+     * returns, so it made the conclusion survive nothing.
      * @min 0
      */
-    materialization_time_ms: number;
+    kept_count?: number;
     /**
-     * TRUE HOMOICONICITY: Number of derived facts persisted to PostgreSQL
-     * (only populated when persist_derived=true in request)
+     * Materialization time in milliseconds
      * @min 0
      */
-    persisted_count?: number;
+    materialization_time_ms: number;
     /**
      * Provenance tags for derived facts (only populated when enable_provenance_tags=true).
      * Each tag maps a derived fact (by index into derived_facts) to its confidence score.
@@ -21319,6 +21625,16 @@ interface OsfSearchStatsDto$1 {
      */
     relations_discovered: number;
 }
+/**
+ * Why the previewed program cannot run as one atomic unit, answered without
+ * running it. The same verdict `POST /api/v1/osfql` would refuse with.
+ */
+interface OsfqlAtomicRefusalDto {
+    /** Machine-readable cause: `drop_sort_in_atomic_program`. */
+    code: string;
+    /** Human-readable explanation, identical to the run-time refusal. */
+    message: string;
+}
 /** Request to diagnose an OSFQL program for contradictions / inconsistencies. */
 interface OsfqlDiagnoseRequest$1 {
     /**
@@ -21355,6 +21671,116 @@ interface OsfqlErrorResponse {
      */
     refusal?: null | OsfqlRefusalDto;
 }
+/**
+ * The rows a destructive statement would affect, counted by running the
+ * derived read-only `MATCH` against a snapshot — never against the live store.
+ */
+interface OsfqlPreviewAffectedDto {
+    /**
+     * How the affected rows fall across sorts, most rows first (#271).
+     *
+     * Present for a statement whose reach is the whole tenant — `CLEAR FACTS`
+     * — where a sample of ten rows says almost nothing and the shape of what
+     * is about to go is the useful answer. Absent otherwise: for a targeted
+     * `RETRACT` the sort is already in `sorts`, and repeating it per row would
+     * be noise.
+     */
+    by_sort?: OsfqlPreviewSortCountDto[];
+    /**
+     * How many rows the statement would affect. `0` means zero rows, and it
+     * is answered whenever the rows were counted; it is the ABSENCE of the
+     * enclosing `affected` block that means "this statement has no
+     * affected-row set" (a read, an additive write).
+     * @min 0
+     */
+    count: number;
+    /**
+     * Whether [`count`](Self::count) is EXACT, or an upper bound.
+     *
+     * `false` for a statement nested under a condition the one-statement probe
+     * cannot carry — a guard naming a variable an earlier statement bound is
+     * free inside the probe, so folding it in would raise an unbound-variable
+     * error and delete the count entirely. The probe then selects a SUPERSET
+     * of what would go, and the honest rendering is "up to N rows" (#276).
+     *
+     * `true` for every top-level statement, and for a nested statement whose
+     * enclosing conditions name only its own variables.
+     */
+    exact?: boolean;
+    /**
+     * Up to 10 sample rows, one map per matched row.
+     *
+     * Each row IDENTIFIES the row it stands for (#271): a `term_id` column,
+     * the features the statement's own pattern projected, and the declaring
+     * sort's `@key` features. Before that it echoed the pattern the caller had
+     * just written — `RETRACT customer(tier: "gold")` over two gold customers
+     * returned two identical `{"tier": "gold"}` rows, so a confirm dialog
+     * could say "this deletes 2 rows" and not WHICH two.
+     */
+    sample_rows?: Partial<Record<string, OsfqlValueDto>>[];
+}
+/**
+ * Response from previewing an OSFQL program: what each statement would do,
+ * decided without running anything (#257).
+ */
+interface OsfqlPreviewResponse$1 {
+    /**
+     * Why the program cannot run as one atomic unit, when it cannot and the
+     * request runs atomically (the default). Absent otherwise.
+     */
+    atomic_refusal?: null | OsfqlAtomicRefusalDto;
+    /**
+     * Whether ANY statement of the program mutates the store — folding every
+     * nested statement, so an `IF` whose branch writes reports `true`, and
+     * including an inline-write `MATCH`, which classifies as a read (#266).
+     */
+    mutates: boolean;
+    /** One entry per top-level statement, in document order. */
+    statements: OsfqlPreviewStatementDto[];
+}
+/** One sort's share of an affected-row set (#271). */
+interface OsfqlPreviewSortCountDto {
+    /**
+     * How many of the affected rows are of this sort.
+     * @min 0
+     */
+    count: number;
+    /** The sort's name, or its id when the tenant's lattice cannot name it. */
+    sort: string;
+}
+/** One statement of a previewed OSFQL program (recursive) */
+interface OsfqlPreviewStatementDto {
+    /**
+     * The rows a destructive statement would affect, counted by running the
+     * derived read-only `MATCH` against a snapshot — never against the live store.
+     */
+    affected?: OsfqlPreviewAffectedDto;
+    id: string;
+    index: number;
+    mutates: boolean;
+    nested?: OsfqlPreviewStatementDto[];
+    /**
+     * Safety tier assigned per entry — a coarse pre-filter. The security boundary
+     * re-derives the real tier per authored statement at execution (see the plan
+     * §9.1); an entry with mixed sub-ops carries its most-dangerous dominant tier.
+     *
+     * WIRE: this enum is `snake_case` in JSON — DELIBERATELY, because it is the
+     * `risk_tier` value on the descriptor-embedded `UIAction` wire contract
+     * (`"targeted_destructive"`, `"additive_write"`, …) that `/ui/action` reads
+     * back and the frontend maps to guardrail flows. `Deserialize` is required for
+     * that same round-trip. A consequence is that the already-live
+     * `GET /api/v1/osfql/catalog` endpoint now serializes its `risk` field
+     * snake_case while sibling enums (`family`/`category`) remain PascalCase — an
+     * intentional, documented casing mix in that DEBUG/introspection endpoint,
+     * which has no in-app consumer (only the catalog handler + its mod re-export).
+     * The sibling casing is left as-is to avoid a broader unannounced change to
+     * that shipped endpoint's other fields.
+     */
+    risk: RiskTier$1;
+    sorts: string[];
+    source: string;
+    statement: string;
+}
 /** A 0-based, UTF-16 source range (LSP-compatible). */
 interface OsfqlRangeDto {
     /**
@@ -23102,6 +23528,10 @@ interface ProvideFeedbackResponse$1 {
  * - `"constraint.*"` - Various constraint types (sort, feature, equality, etc.)
  * - `"variable"` - A logic variable with optional `_name`
  * - Any domain sort (person, document, etc.)
+ * `PartialEq` is required by [`FeatureValueDto`], which derives it and now
+ * carries a `PsiTermDto` in its `Term` variant (#267). The recursion is by
+ * `Box`, and the OpenAPI schemas reference each other by `$ref` rather than
+ * inlining, so neither the compiler nor the spec builder loops.
  */
 interface PsiTermDto$1 {
     /**
@@ -23461,17 +23891,56 @@ interface RebuildDerivedFactsResponse {
      * Per-tenant materialization LSN at the moment the response was
      * produced. Read-side caches consult this value to know whether
      * they have observed every successfully applied event.
+     *
+     * ⚠️ Read BEFORE the queued bootstrap runs, so it is the last COMPLETED
+     * lsn, not this rebuild's.
      * @format int64
      * @min 0
      */
     materialization_lsn: number;
     /**
-     * Number of rows truncated from `derived_facts` for this tenant.
+     * Derived TERMS the synchronous re-chain put back into the tenant's
+     * RESIDENT store — the set every read surface answers from (#270).
+     *
+     * ⚠️ Terms, not distinct conclusions: one conclusion is materialised as a
+     * `meta.clause` wrapper plus the literal-queryable inner copy a `MATCH`
+     * reads, so the number here is larger than the row count a browse of the
+     * conclusion sort returns. Read it as "the repair did work", not as a row
+     * count.
+     *
+     * Non-zero means the tenant HAD drifted and is now repaired; `0` on a
+     * healthy tenant means there was nothing provable that was not already
+     * materialised. This is the field that makes the endpoint a repair rather
+     * than a report: before #270 it truncated an empty durable table, queued
+     * an event no reader observes, and answered `removed: 0` while the
+     * materialised set stayed exactly as drifted as it was.
+     *
+     * ⚠️ ONE DIRECTION: it re-materialises what the rules prove and the store
+     * lacks, and does not remove a conclusion the rules no longer support.
+     * That is the write doors' truth maintenance (#241, #260), which runs on
+     * the write that changed the premise — so a store where the two disagree
+     * is a defect in that machinery, not a state this endpoint exists to mop
+     * up.
+     * @min 0
+     */
+    rematerialised: number;
+    /**
+     * Number of rows truncated from the DURABLE `derived_facts` table for
+     * this tenant.
+     *
+     * ⚠️ Not a count any reader feels: no OSFQL `CHAIN` ever writes that
+     * table, so a tenant built through OSFQL reports `0` here whatever its
+     * materialised set holds, and no read surface consults it. The field that
+     * describes what a reader will see is [`Self::rematerialised`] (#270).
      * @min 0
      */
     removed: number;
     /**
      * Number of `BootstrapRule` events queued to the supervisor.
+     *
+     * ⚠️ The size of the ruleset the queued bootstrap will process, not a
+     * count of work that has finished. The bootstrap writes the durable
+     * `derived_facts` table, which no read surface consults.
      * @min 0
      */
     rules_queued: number;
@@ -23845,8 +24314,24 @@ interface RegisterFunctionRequest$1 {
     arity: number;
     clauses: FunctionClauseDto$1[];
     name: string;
-    /** @format uuid */
-    tenant_id: string;
+    /**
+     * OPTIONAL, and ignored when it agrees with `X-Tenant-Id`: the tenant is
+     * the authenticated principal's, never a body field.
+     *
+     * It was mandatory until #268, which made the route refuse a body without
+     * it — a field the handler then discarded. That is the shape
+     * `ReplaceFunctionRequest` had already rejected for `PUT`, and the
+     * generated SDK documented `FunctionDraftDto` as "RegisterFunctionRequest
+     * minus tenant_id" while the route demanded it, so the doc and the route
+     * disagreed.
+     *
+     * A value that CONTRADICTS the header is refused with
+     * `function_tenant_mismatch` rather than discarded: the isolation was
+     * always right, but the caller was never told the request had said
+     * something false.
+     * @format uuid
+     */
+    tenant_id?: string | null;
 }
 /** Response from function registration */
 interface RegisterFunctionResponse$1 {
@@ -27848,7 +28333,7 @@ interface SortDto$1 {
      * equivalence **hypotheses** a curator confirms — never identities the
      * engine asserts.
      */
-    coextensive?: CoextensiveDefinitionDto[];
+    coextensive?: CoextensiveDefinitionDto$1[];
     /**
      * The ONE defining formula of a *defined* sort, rendered
      * (`mod_3∘id(day) = 1`). `None` for a nominal sort. Without it a client
@@ -29961,6 +30446,22 @@ interface TermBindingDto$1 {
 }
 /** API representation of a term */
 interface TermDto$1 {
+    /**
+     * The rule that FIRST materialised this conclusion, `None` for an
+     * asserted fact (#261). Read from the same `_derived_by` marker `origin`
+     * is read from, and joinable with the rule id in
+     * `GET /api/v1/inference/rules`.
+     *
+     * ⚠️ An ATTRIBUTION, not the proof set. A conclusion proved by a second
+     * rule keeps the first materialiser's id, exactly as `derived_facts.rule_id`
+     * does (#231). For every recorded firing, ask
+     * `POST /api/v1/inference/backward-chain`.
+     *
+     * Response-only: every write door refuses `_derived_by`
+     * (`is_engine_reserved_feature`), so a caller cannot assert provenance.
+     * @format uuid
+     */
+    derived_by?: string | null;
     /**
      * Human-readable display name extracted from features under a total,
      * deterministic precedence: a feature the sort annotates `displayLabel`,
@@ -30026,6 +30527,7 @@ interface TermExistsResponse {
  * TermInputDto
  * Input for creating/referencing a term (TRUE HOMOICONICITY). Either:
  * - {term_id: UUID} to reference an existing term, OR
+ * - {designator: {sort_name, features}} to address an existing term through its sort's @key, OR
  * - {sort_id: UUID, features: {...}} to define inline with sort ID, OR
  * - {sort_name: String, features: {...}} to define inline with sort name (resolved server-side)
  * An inline antecedent may carry binding: "?C" to name its own identity.
@@ -30033,6 +30535,8 @@ interface TermExistsResponse {
 type TermInputDto$1 = {
     /** @format uuid */
     term_id: string;
+} | {
+    designator: object;
 } | {
     /** Binder naming this clause's own identity (`?C`), shared with every `{"name": "?C"}` in the rule — the OSFQL `?C: sort(...)` join */
     binding?: string;
@@ -30065,12 +30569,30 @@ interface TermListRequest {
 /** Response for term list operations */
 interface TermListResponse$1 {
     /**
-     * Total count
+     * Rows in THIS page. Equal to `terms.len()`. The doc comment used to read
+     * "Total count" and never meant it — every producer sets the page length
+     * — so the true size moved to `total` rather than silently changing this
+     * value under existing clients (#261).
      * @min 0
      */
     count: number;
+    /**
+     * A truthful remark about an answer a caller could otherwise misread —
+     * today, the one case of an EMPTY answer for a sort whose membership is
+     * derived (#261). Both `GET /api/v1/terms` and
+     * `POST /api/v1/query/by-sort` set it, with the remedy each route can
+     * honestly offer. Never an error and never a substitute for
+     * one; ignore it and the rows beside it are still correct.
+     */
+    note?: string | null;
     /** List of terms */
     terms: TermDto$1[];
+    /**
+     * Rows the request matched BEFORE `offset`/`limit`. `None` on a route
+     * that does not page. A counted size, never a search bound.
+     * @min 0
+     */
+    total?: number | null;
 }
 /**
  * Provenance of a fact on a read surface (#250).
@@ -30393,6 +30915,19 @@ interface ThresholdAnchorDto {
      */
     threshold: number;
 }
+/**
+ * A `504` body. `error` and `message` are unchanged from [`ErrorResponse`];
+ * `error_type` is the discriminator `POST /api/v1/osfql` already publishes, so
+ * a client handles ONE timeout contract across both routes (#252, #256).
+ */
+interface TimeoutErrorResponse {
+    /** The canonical status reason, `"Gateway Timeout"`. */
+    error: string;
+    /** Always `"timeout"`. */
+    error_type: string;
+    /** What was abandoned, and the knob that raises or removes the bound. */
+    message: string;
+}
 /** Token usage from LLM API calls during ingestion */
 interface TokenUsageDto$1 {
     /**
@@ -31902,8 +32437,13 @@ type ValueDto$1 = {
     type: "Uninstantiated";
 } | {
     type: "Reference";
-    /** @format uuid */
-    value: string;
+    /** The referenced term's id */
+    value: string | {
+        /** The @key feature values that pick one term out of that extent */
+        features: Record<string, ValueDto$1>;
+        /** The sort whose extent the designator addresses */
+        sort_name: string;
+    };
 } | {
     type: "SortId";
     /** @format uuid */
@@ -33238,10 +33778,67 @@ interface BooleanValue {
 interface UninstantiatedValue {
     type: 'Uninstantiated';
 }
-/** A reference to another term by UUID. Produces `{"type": "Reference", "value": "uuid"}`. */
+/**
+ * A designator that names a stored term by its `@key` values instead of by id.
+ *
+ * @remarks
+ * The SDK surface spells the sort key `sortName`; the wire spells it
+ * `sort_name`. `features` is a USER-KEYED map — its keys are the OSF feature
+ * names the sort declares, so they are carried verbatim through the request
+ * bridge (`features` is in `USER_DATA_FIELDS`) and a camelCase feature such as
+ * `invoiceNumber` is NOT snake_cased.
+ *
+ * **Every named feature must be declared `@key` on that sort**, and the
+ * designator must name at least one. Measured against the engine on
+ * 2026-09-18:
+ *
+ * - a feature that is not `@key` →
+ *   `422 feature 'label' of sort 'nokey' is not a @key feature; a designator addresses a term only through its @key`
+ * - an empty map →
+ *   `422 a reference designator for sort 'invoice' names no feature`
+ * - an unknown sort →
+ *   `422 reference designator names unknown sort 'no_such_sort'`
+ * - no term carrying the key →
+ *   `422 no term of sort 'invoice' carries @key 'number' = "INV-NOPE"; a reference designator names an existing term, it never creates one`
+ *
+ * @example
+ * ```typescript
+ * const designator: ReferenceDesignator = {
+ *   sortName: 'invoice',
+ *   features: { number: { type: 'String', value: 'INV-1' } },
+ * };
+ * ```
+ */
+interface ReferenceDesignator {
+    /** The sort whose extent the designator addresses. */
+    sortName: string;
+    /** The `@key` feature values that pick one term out of that extent. */
+    features: Record<string, ValueDto>;
+}
+/**
+ * A reference to another term, by UUID or by `@key` designator.
+ *
+ * @remarks
+ * Produces `{"type": "Reference", "value": "uuid"}` for the id form and
+ * `{"type": "Reference", "value": {"sort_name": "...", "features": {...}}}`
+ * for the designator form.
+ *
+ * **The two forms are not interchangeable.** The designator is a WRITE-side
+ * convenience: it RESOLVES to an existing term, and the engine refuses it when
+ * nothing matches — it never mints the target. A READ always answers the
+ * resolved UUID form, so a response never carries a designator. Measured on
+ * 2026-09-18: a term written with
+ * `{"type":"Reference","value":{"sort_name":"invoice","features":{"number":{"type":"String","value":"INV-1"}}}}`
+ * reads back as `{"type":"Reference","value":"4641cbcb-79f4-413a-b4a4-2ba5d6bebf8d"}`
+ * — the id of the invoice that already existed — and the invoice extent still
+ * held exactly one term.
+ *
+ * See {@link ReferenceDesignator} for the refusals the designator form can
+ * produce.
+ */
 interface ReferenceValue {
     type: 'Reference';
-    value: string;
+    value: string | ReferenceDesignator;
 }
 /**
  * A reference to a sort by UUID. Produces `{"type": "SortId", "value": "uuid"}`.
@@ -33861,6 +34458,7 @@ type values_Point2DGeometry = Point2DGeometry;
 type values_PolygonGeometry = PolygonGeometry;
 type values_PsiTermValue = PsiTermValue;
 type values_RealValue = RealValue;
+type values_ReferenceDesignator = ReferenceDesignator;
 type values_ReferenceValue = ReferenceValue;
 type values_SShapeShape = SShapeShape;
 type values_SetValue = SetValue;
@@ -33879,7 +34477,7 @@ type values_ValueDto = ValueDto;
 type values_VariableFeatureValue = VariableFeatureValue;
 type values_ZShapeShape = ZShapeShape;
 declare namespace values {
-  export type { values_BellShape as BellShape, values_BigIntegerValue as BigIntegerValue, values_BooleanValue as BooleanValue, values_BoundingBoxGeometry as BoundingBoxGeometry, values_CauchyShape as CauchyShape, values_ChoiceValue as ChoiceValue, values_CircleGeometry as CircleGeometry, values_CosineShape as CosineShape, values_CyclicGaussianShape as CyclicGaussianShape, values_DateTimeValue as DateTimeValue, values_DomainValue as DomainValue, values_ExternalRefValue as ExternalRefValue, values_FeatureTargetDto as FeatureTargetDto, values_FeatureValueDto as FeatureValueDto, values_FuzzyNumberValue as FuzzyNumberValue, values_FuzzyScalarValue as FuzzyScalarValue, values_FuzzyShapeDto as FuzzyShapeDto, values_GaussianProductShape as GaussianProductShape, values_GaussianShape as GaussianShape, values_GeometryDto as GeometryDto, values_GeometryValue as GeometryValue, values_IntegerValue as IntegerValue, values_ListValue as ListValue, values_LiteralFeatureValue as LiteralFeatureValue, values_MeasurementUnitDto as MeasurementUnitDto, values_MeasurementValue as MeasurementValue, values_PiShapeShape as PiShapeShape, values_PiecewiseLinearShape as PiecewiseLinearShape, values_Point2DGeometry as Point2DGeometry, values_PolygonGeometry as PolygonGeometry, values_PsiTermValue as PsiTermValue, values_RealValue as RealValue, values_ReferenceValue as ReferenceValue, values_SShapeShape as SShapeShape, values_SetValue as SetValue, values_SigmoidDifferenceShape as SigmoidDifferenceShape, values_SigmoidProductShape as SigmoidProductShape, values_SigmoidShape as SigmoidShape, values_SortIdValue as SortIdValue, values_SpikeShape as SpikeShape, values_StringValue as StringValue, values_TaggedFeatureValueDto as TaggedFeatureValueDto, values_TermRefFeatureValue as TermRefFeatureValue, values_TrapezoidalShape as TrapezoidalShape, values_TriangularShape as TriangularShape, values_UninstantiatedValue as UninstantiatedValue, values_ValueDto as ValueDto, values_VariableFeatureValue as VariableFeatureValue, values_ZShapeShape as ZShapeShape };
+  export type { values_BellShape as BellShape, values_BigIntegerValue as BigIntegerValue, values_BooleanValue as BooleanValue, values_BoundingBoxGeometry as BoundingBoxGeometry, values_CauchyShape as CauchyShape, values_ChoiceValue as ChoiceValue, values_CircleGeometry as CircleGeometry, values_CosineShape as CosineShape, values_CyclicGaussianShape as CyclicGaussianShape, values_DateTimeValue as DateTimeValue, values_DomainValue as DomainValue, values_ExternalRefValue as ExternalRefValue, values_FeatureTargetDto as FeatureTargetDto, values_FeatureValueDto as FeatureValueDto, values_FuzzyNumberValue as FuzzyNumberValue, values_FuzzyScalarValue as FuzzyScalarValue, values_FuzzyShapeDto as FuzzyShapeDto, values_GaussianProductShape as GaussianProductShape, values_GaussianShape as GaussianShape, values_GeometryDto as GeometryDto, values_GeometryValue as GeometryValue, values_IntegerValue as IntegerValue, values_ListValue as ListValue, values_LiteralFeatureValue as LiteralFeatureValue, values_MeasurementUnitDto as MeasurementUnitDto, values_MeasurementValue as MeasurementValue, values_PiShapeShape as PiShapeShape, values_PiecewiseLinearShape as PiecewiseLinearShape, values_Point2DGeometry as Point2DGeometry, values_PolygonGeometry as PolygonGeometry, values_PsiTermValue as PsiTermValue, values_RealValue as RealValue, values_ReferenceDesignator as ReferenceDesignator, values_ReferenceValue as ReferenceValue, values_SShapeShape as SShapeShape, values_SetValue as SetValue, values_SigmoidDifferenceShape as SigmoidDifferenceShape, values_SigmoidProductShape as SigmoidProductShape, values_SigmoidShape as SigmoidShape, values_SortIdValue as SortIdValue, values_SpikeShape as SpikeShape, values_StringValue as StringValue, values_TaggedFeatureValueDto as TaggedFeatureValueDto, values_TermRefFeatureValue as TermRefFeatureValue, values_TrapezoidalShape as TrapezoidalShape, values_TriangularShape as TriangularShape, values_UninstantiatedValue as UninstantiatedValue, values_ValueDto as ValueDto, values_VariableFeatureValue as VariableFeatureValue, values_ZShapeShape as ZShapeShape };
 }
 
 /**
@@ -33918,20 +34516,58 @@ interface PsiTermDto {
 /**
  * Input type for specifying a term in inference requests.
  *
- * A structural (untagged) union with three variants:
- * 1. **Reference** — `{ term_id: string }` — reference an existing term by UUID
- * 2. **Inline by sort ID** — `{ sort_id: string, features?: ... }` — define inline by sort UUID
- * 3. **Inline by sort name** — `{ sort_name: string, features?: ... }` — define inline by sort name
+ * A structural (untagged) union with four variants:
+ * 1. **Reference** — `{ term_id: string }` — an existing term, by UUID
+ * 2. **Designator** — `{ designator: { sort_name, features } }` — an existing term, by its sort's `@key`
+ * 3. **Inline by sort ID** — `{ sort_id: string, features?: ... }` — define inline by sort UUID
+ * 4. **Inline by sort name** — `{ sort_name: string, features?: ... }` — define inline by sort name
  *
  * @remarks
  * **Serialization format: Untagged (structural discrimination).**
  *
- * The backend Rust type is `TermInputDto` in `dto/homoiconic.rs` with `#[serde(untagged)]`.
- * The backend tries each variant in order: Reference, Inline, InlineByName.
+ * The backend Rust type is `TermInputDto` in `dto/homoiconic.rs` with
+ * `#[serde(untagged)]`, and it tries each variant in declaration order:
+ * Reference, Designator, Inline, InlineByName.
  *
  * Use `TermInput.*` builders to construct these values safely.
  */
-type TermInputDto = TermInputRef | TermInputInline | TermInputInlineByName;
+type TermInputDto = TermInputRef | TermInputDesignator | TermInputInline | TermInputInlineByName;
+/**
+ * An existing term, addressed through its sort's `@key`.
+ *
+ * @remarks
+ * The one variant that neither creates a term nor describes a pattern: it
+ * NAMES a term that already exists, the way {@link TermInputRef} does, but by
+ * the key a caller actually holds rather than by a UUID it does not.
+ *
+ * ⚠️ **Its `features` are TAGGED, inside an otherwise untagged union.** The
+ * backend field is a `ReferenceDesignatorDto`, whose features are
+ * `HashMap<String, ValueDto>` — the term-CRUD format. Measured 2026-09-19:
+ * `{"designator":{"sort_name":"invoice","features":{"number":{"type":"String","value":"INV-1"}}}}`
+ * resolves, while the untagged `{"number":"INV-1"}` is refused with
+ * `422 data did not match any variant of untagged enum TermInputDto`. This is
+ * the one place the two serialization formats meet, and the reason
+ * {@link ReferenceDesignator} is reused here rather than restated.
+ *
+ * What it does, all measured:
+ * - resolves to the term that already exists and mints nothing — `200`, and
+ *   the sort's extent is unchanged;
+ * - a key matching nothing is refused: `no term of sort 'invoice' carries
+ *   @key 'number' = "NOPE"; a reference designator names an existing term, it
+ *   never creates one`;
+ * - a NON-key feature is refused: `feature 'status' of sort 'invoice' is not a
+ *   @key feature; a designator addresses a term only through its @key`. A
+ *   designator is an address, not a filter.
+ *
+ * ⚠️ **A PATTERN door refuses it.** A rule antecedent answers `rule rejected:
+ * antecedent 0 could not be resolved (a \`designator\` addresses an existing
+ * term of sort \`invoice\` and this route does not resolve one…)`, and a
+ * backward-chain goal answers `400 Invalid goal term`. A pattern has no extent
+ * to address, so use {@link TermInputInline} there.
+ */
+interface TermInputDesignator {
+    designator: ReferenceDesignator;
+}
 /** Reference an existing term by UUID. */
 interface TermInputRef {
     termId: string;
@@ -34046,12 +34682,172 @@ type homoiconic_FeatureInputTermRef = FeatureInputTermRef;
 type homoiconic_FeatureInputValueDto = FeatureInputValueDto;
 type homoiconic_FeatureInputVariable = FeatureInputVariable;
 type homoiconic_PsiTermDto = PsiTermDto;
+type homoiconic_TermInputDesignator = TermInputDesignator;
 type homoiconic_TermInputDto = TermInputDto;
 type homoiconic_TermInputInline = TermInputInline;
 type homoiconic_TermInputInlineByName = TermInputInlineByName;
 type homoiconic_TermInputRef = TermInputRef;
 declare namespace homoiconic {
-  export type { homoiconic_FeatureInputConstrainedVariable as FeatureInputConstrainedVariable, homoiconic_FeatureInputInlineTerm as FeatureInputInlineTerm, homoiconic_FeatureInputInlineTermByName as FeatureInputInlineTermByName, homoiconic_FeatureInputSortRef as FeatureInputSortRef, homoiconic_FeatureInputTermRef as FeatureInputTermRef, homoiconic_FeatureInputValueDto as FeatureInputValueDto, homoiconic_FeatureInputVariable as FeatureInputVariable, homoiconic_PsiTermDto as PsiTermDto, homoiconic_TermInputDto as TermInputDto, homoiconic_TermInputInline as TermInputInline, homoiconic_TermInputInlineByName as TermInputInlineByName, homoiconic_TermInputRef as TermInputRef };
+  export type { homoiconic_FeatureInputConstrainedVariable as FeatureInputConstrainedVariable, homoiconic_FeatureInputInlineTerm as FeatureInputInlineTerm, homoiconic_FeatureInputInlineTermByName as FeatureInputInlineTermByName, homoiconic_FeatureInputSortRef as FeatureInputSortRef, homoiconic_FeatureInputTermRef as FeatureInputTermRef, homoiconic_FeatureInputValueDto as FeatureInputValueDto, homoiconic_FeatureInputVariable as FeatureInputVariable, homoiconic_PsiTermDto as PsiTermDto, homoiconic_TermInputDesignator as TermInputDesignator, homoiconic_TermInputDto as TermInputDto, homoiconic_TermInputInline as TermInputInline, homoiconic_TermInputInlineByName as TermInputInlineByName, homoiconic_TermInputRef as TermInputRef };
+}
+
+/**
+ * A format-agnostic psi-term produced by the `psi()` builder.
+ *
+ * @remarks
+ * Can be passed to both term CRUD methods (converted to tagged `ValueDto` format)
+ * and inference methods (converted to untagged `TermInputDto` format).
+ * The SDK handles the conversion automatically based on which method receives it.
+ *
+ * Distinguished from plain objects by the `__psiTerm` brand field, which is
+ * stripped before serialization.
+ *
+ * @example
+ * ```typescript
+ * // Works with term CRUD:
+ * await client.terms.createTerm({ sortId, ownerId, features: { name: "Alice" } });
+ *
+ * // Works with inference:
+ * await client.inference.addFact({ term: psi("person", { name: "Alice" }) });
+ * ```
+ */
+/**
+ * A psi-term identified by sort name.
+ */
+interface PsiTermInputByName {
+    /** @internal Brand field to distinguish from plain objects. Stripped before serialization. */
+    readonly __psiTerm: true;
+    /** Sort name for this term (resolved server-side). */
+    readonly sortName: string;
+    /** Features using plain JavaScript values. */
+    readonly features?: PlainFeatureMap;
+    /**
+     * Binder naming this term's own identity (`?C`), from {@link bind}.
+     *
+     * @remarks
+     * Only meaningful in an inference context, where it writes the OSFQL
+     * `?C: sort(...)` join.
+     */
+    readonly binding?: string;
+}
+/**
+ * A psi-term identified by sort ID (UUID).
+ */
+interface PsiTermInputById {
+    /** @internal Brand field to distinguish from plain objects. Stripped before serialization. */
+    readonly __psiTerm: true;
+    /** Sort ID (UUID) for this term. */
+    readonly sortId: string;
+    /** Features using plain JavaScript values. */
+    readonly features?: PlainFeatureMap;
+    /**
+     * Binder naming this term's own identity (`?C`), from {@link bind}.
+     *
+     * @remarks
+     * Only meaningful in an inference context, where it writes the OSFQL
+     * `?C: sort(...)` join.
+     */
+    readonly binding?: string;
+}
+/**
+ * A format-agnostic psi-term produced by the `psi()` builder.
+ *
+ * @remarks
+ * Exactly one of `sortName` or `sortId` is present — enforced by the union type.
+ * Can be passed to both term CRUD methods (converted to tagged `ValueDto` format)
+ * and inference methods (converted to untagged `TermInputDto` format).
+ * The SDK handles the conversion automatically based on which method receives it.
+ *
+ * Distinguished from plain objects by the `__psiTerm` brand field, which is
+ * stripped before serialization.
+ *
+ * @example
+ * ```typescript
+ * // Works with term CRUD:
+ * await client.terms.createTerm({ sortId, ownerId, features: { name: "Alice" } });
+ *
+ * // Works with inference:
+ * await client.inference.addFact({ term: psi("person", { name: "Alice" }) });
+ * ```
+ */
+type PsiTermInput = PsiTermInputByName | PsiTermInputById;
+/**
+ * A constrained variable for use in inference contexts.
+ *
+ * @remarks
+ * Created via the `constrained()` helper. Distinguished from plain arrays
+ * by the `__constrainedVar` brand field, which is stripped before serialization.
+ *
+ * @example
+ * ```typescript
+ * psi("eligible", { score: constrained("?S", guard("gt", 700)) })
+ * ```
+ */
+interface ConstrainedPlainVar {
+    /** @internal Brand field. Stripped before serialization. */
+    readonly __constrainedVar: true;
+    /** Variable name (must start with "?"). */
+    readonly name: string;
+    /** Constraint as a TermInputDto or PsiTermInput. */
+    readonly constraint: TermInputDto | PsiTermInput;
+}
+/**
+ * A plain JavaScript value that the SDK auto-converts to the correct wire format.
+ *
+ * @remarks
+ * The SDK converts this to either tagged `ValueDto` or untagged `FeatureInputValueDto`
+ * depending on which resource client method receives it:
+ *
+ * - `string` — string value (or variable if `?`-prefixed in inference context)
+ * - `number` — integer if `Number.isInteger()`, real otherwise
+ * - `boolean` — boolean value
+ * - `null` — uninstantiated
+ * - `PsiTermInput` — nested inline term (from `psi()` builder)
+ * - `ConstrainedPlainVar` — constrained variable (from `constrained()` helper)
+ * - `PlainFeatureValue[]` — list of values
+ * - `ValueDto` — passthrough (already in tagged format)
+ * - `FeatureInputValueDto` — passthrough (already in untagged format)
+ *
+ * Fuzzy and set values cannot be expressed as plain JS values. Use `Value.fuzzyScalar()`,
+ * `Value.fuzzyNumber()`, or `Value.set()` directly — they pass through unchanged.
+ */
+type PlainFeatureValue = string | number | boolean | null | PsiTermInput | ConstrainedPlainVar | PlainFeatureValue[] | ValueDto | FeatureInputValueDto;
+/**
+ * A feature map using plain JavaScript values.
+ *
+ * @remarks
+ * Pass this to resource client methods. The SDK converts to the appropriate
+ * wire format (tagged or untagged) based on which method is called.
+ *
+ * @example
+ * ```typescript
+ * const features: PlainFeatureMap = {
+ *   name: "Alice",
+ *   age: 30,
+ *   active: true,
+ *   salary: null,  // uninstantiated
+ * };
+ * ```
+ */
+type PlainFeatureMap = Record<string, PlainFeatureValue>;
+/**
+ * Union of PsiTermInput or already-formatted TermInputDto.
+ *
+ * @remarks
+ * Accepted by inference resource client methods that take term inputs.
+ * If a `PsiTermInput` is passed, it is converted to `TermInputDto` internally.
+ */
+type TermInputArg = PsiTermInput | TermInputDto;
+
+type plainValues_ConstrainedPlainVar = ConstrainedPlainVar;
+type plainValues_PlainFeatureMap = PlainFeatureMap;
+type plainValues_PlainFeatureValue = PlainFeatureValue;
+type plainValues_PsiTermInput = PsiTermInput;
+type plainValues_PsiTermInputById = PsiTermInputById;
+type plainValues_PsiTermInputByName = PsiTermInputByName;
+type plainValues_TermInputArg = TermInputArg;
+declare namespace plainValues {
+  export type { plainValues_ConstrainedPlainVar as ConstrainedPlainVar, plainValues_PlainFeatureMap as PlainFeatureMap, plainValues_PlainFeatureValue as PlainFeatureValue, plainValues_PsiTermInput as PsiTermInput, plainValues_PsiTermInputById as PsiTermInputById, plainValues_PsiTermInputByName as PsiTermInputByName, plainValues_TermInputArg as TermInputArg };
 }
 
 /**
@@ -34162,6 +34958,24 @@ interface TermDto {
      * is writing over a conclusion the engine will recompute.
      */
     origin?: TermOrigin;
+    /**
+     * The rule that FIRST materialised this conclusion, absent on an asserted
+     * fact.
+     *
+     * @remarks
+     * Joinable with the rule id from `client.inference.getRules()`, so a UI can
+     * show "concluded by <rule>" beside a `derived` row instead of only "not
+     * yours to edit".
+     *
+     * ⚠️ An ATTRIBUTION, not the proof set. A conclusion a second rule also
+     * proves keeps the FIRST materialiser's id. For every recorded firing ask
+     * `client.inference.backwardChain(...)`.
+     *
+     * Response-only. Every write door refuses the underlying `_derived_by`
+     * marker, so a caller cannot assert provenance — sending it is a refusal,
+     * not a shortcut.
+     */
+    derivedBy?: string;
 }
 /**
  * Response wrapper for term CRUD operations.
@@ -34195,7 +35009,52 @@ interface CreateTermRequest {
     ownerId: string;
     /** Named features with tagged values. */
     features: Record<string, ValueDto>;
+    /**
+     * A client-minted id for the new term.
+     *
+     * @remarks
+     * Omit it and the engine mints one. Supplying it lets a batch reference the
+     * ids it is itself creating — see {@link BulkAddTermsRequest}.
+     */
+    id?: string;
+}
+/**
+ * A term write that names its sort by NAME rather than by id.
+ *
+ * @remarks
+ * `POST /api/v1/inference/facts` and every OSFQL write have always taken a
+ * sort name; the term routes took only a UUID, so a caller holding names had
+ * to resolve every sort first — worst on the bulk route, the one place the
+ * extra round trips cost most, because it exists for volume.
+ *
+ * Exactly one of the two spellings per entry. Both deny unknown fields on the
+ * wire, so an entry carrying `sort_id` AND `sort_name` matches neither and is
+ * refused — measured, `422 data did not match any variant of untagged enum
+ * CreateTermInput`. A name this tenant does not declare is refused too, and it
+ * never mints a sort: `422 unknown sort \`nosuch\`: this tenant declares no
+ * sort by that name. Declare it first, or name the sort by \`sort_id\`.`
+ *
+ * **Serialization format**: features use the tagged {@link ValueDto} format,
+ * like every term-CRUD route.
+ */
+interface CreateTermByNameRequest {
+    /** The sort's name, resolved against the tenant's lattice. */
+    sortName: string;
+    /** Owner user ID (UUID). */
+    ownerId: string;
+    /** Named features with tagged values. */
+    features: Record<string, ValueDto>;
+    /** A client-minted id, read exactly as {@link CreateTermRequest.id}. */
+    id?: string;
 }
+/**
+ * A term write, naming its sort by id or by name.
+ *
+ * @remarks
+ * A single batch may mix the two spellings freely — measured, one bulk call
+ * carrying one entry of each answered `201` with two ids.
+ */
+type CreateTermInput = CreateTermRequest | CreateTermByNameRequest;
 /**
  * Request to update an existing term.
  *
@@ -34209,8 +35068,94 @@ interface UpdateTermRequest {
 }
 /** Request to bulk-create terms. */
 interface BulkAddTermsRequest {
-    /** Terms to create. */
-    terms: CreateTermRequest[];
+    /** Terms to create, each naming its sort by id or by name. */
+    terms: CreateTermInput[];
+    /**
+     * Run every check the write runs, then write nothing.
+     *
+     * @remarks
+     * Conversion, declarations, coreference and events all run, inside the write
+     * lock, and the store and facade are put back before the route answers.
+     * Nothing persists, nothing is notified, no derivation is queued.
+     *
+     * A clean dry run answers the count the batch WOULD have produced and no
+     * {@link BulkAddTermsResponse.termIds}: the rollback already discarded every
+     * id it minted, and a later real write mints different ones — so the vector
+     * would have named nothing. The ids that DO outlive a dry run are the
+     * entities a `@key` coreference would have merged into, and those come back
+     * as {@link BulkAddTermsResponse.coreferencedTermIds}.
+     *
+     * A refused dry run answers the same per-row refusals the real write answers
+     * with, as {@link BulkRefusedError}.
+     *
+     * @defaultValue `false`
+     */
+    dryRun?: boolean;
+    /**
+     * Write the rows the checks did NOT refuse, instead of refusing the batch
+     * because one row failed.
+     *
+     * @remarks
+     * Without it a batch holding one bad record has to be resent minus that
+     * record — a second full call, a second full round of constraint evaluation,
+     * and a window in which a survivor's reference target can be deleted between
+     * the two — although the engine already names every bad row by index in one
+     * pass and therefore already knows which ones were fine.
+     *
+     * With it the answer is `201` when anything was written, and
+     * {@link BulkAddTermsResponse.termIds} carries one id per ACCEPTED row with
+     * {@link BulkAddTermsResponse.errors} beside it. When every row was refused
+     * the answer is still a {@link BulkRefusedError}, because nothing was
+     * written and that is a refusal.
+     *
+     * Two failures stay batch-wide even under this flag, because neither can be
+     * attributed to a row: the end-of-batch constraint propagation answers one
+     * `409` for the whole batch, and a persistence failure reverts what the
+     * batch inserted.
+     *
+     * @defaultValue `false`
+     */
+    partial?: boolean;
+}
+/**
+ * What {@link TermsClient.bulkCreateTerms} takes.
+ *
+ * @remarks
+ * {@link BulkAddTermsRequest} with the features relaxed: each row's features
+ * may be plain JS values (`"Alice"`, `30`, `true`, `null`, `[...]`), which the
+ * client tags into {@link ValueDto} before it sends them. Pre-built `Value.*`
+ * output passes through untouched.
+ *
+ * `dryRun` and `partial` are inherited from {@link BulkAddTermsRequest}, with
+ * their meaning documented there.
+ */
+interface BulkCreateTermsRequest extends Omit<BulkAddTermsRequest, 'terms'> {
+    /** The rows to create, features as plain values or as `Value.*` output. */
+    terms: CreateTermInputWithPlainFeatures[];
+}
+/**
+ * A term write in either spelling, with features as plain JavaScript values.
+ *
+ * @remarks
+ * The ergonomic form of {@link CreateTermInput}: the resource methods take
+ * this and tag the features before they reach the wire. Naming the sort by
+ * {@link CreateTermByNameRequest.sortName} or by
+ * {@link CreateTermRequest.sortId} is the caller's choice per entry, and a
+ * single batch may mix them.
+ */
+type CreateTermInputWithPlainFeatures = (Omit<CreateTermRequest, 'features'> & {
+    features: PlainFeatureMap;
+}) | (Omit<CreateTermByNameRequest, 'features'> & {
+    features: PlainFeatureMap;
+});
+/** One row a bulk write refused, named by its position in the request. */
+interface BulkRowRefusal {
+    /** Zero-based index into the request's `terms` array. */
+    index: number;
+    /** The refusal in words — the same message a single-term write answers with. */
+    message: string;
+    /** The feature the refusal names, when it names one. */
+    feature?: string;
 }
 /** Response from clearing all terms for a tenant. */
 interface ClearTermsResponse {
@@ -34221,8 +35166,42 @@ interface ClearTermsResponse {
 }
 /** Response from bulk term creation. */
 interface BulkAddTermsResponse {
-    /** UUIDs of the created terms, in the same order as the request. */
-    termIds: string[];
+    /**
+     * Effective term id per accepted row, in request order.
+     *
+     * @remarks
+     * The created id, or the EXISTING entity's id when the row coreferenced into
+     * it through a `@key`. Absent on a dry run, where the ids were rolled back —
+     * see {@link BulkAddTermsRequest.dryRun}. Under
+     * {@link BulkAddTermsRequest.partial} it carries one id per ACCEPTED row, so
+     * it is shorter than the request when {@link errors} is non-empty; use
+     * `errors[].index` to map a refusal back to its row, never this array's
+     * positions.
+     */
+    termIds?: string[];
+    /** How many terms the write created (or would have created, on a dry run). */
+    termsAdded: number;
+    /** Whether the request asked for a dry run, echoed so an answer is self-describing. */
+    dryRun: boolean;
+    /** How many rows were refused. Absent when none were. */
+    refused?: number;
+    /**
+     * The rows the write refused, each with its index in the request.
+     *
+     * @remarks
+     * Present on a `201` under {@link BulkAddTermsRequest.partial}, where some
+     * rows landed and some did not. When EVERY row was refused the route answers
+     * a {@link BulkRefusedError} instead, which carries the same list.
+     */
+    errors?: BulkRowRefusal[];
+    /**
+     * Existing entities a `@key` coreference merged a row into.
+     *
+     * @remarks
+     * These outlive a dry run, because they existed before it: they are the one
+     * kind of id a dry run can honestly report.
+     */
+    coreferencedTermIds?: string[];
     /** Total processing time in milliseconds. */
     processingTimeMs: number;
 }
@@ -34403,7 +35382,12 @@ interface TermVersionsResponse {
 
 type terms_BulkAddTermsRequest = BulkAddTermsRequest;
 type terms_BulkAddTermsResponse = BulkAddTermsResponse;
+type terms_BulkCreateTermsRequest = BulkCreateTermsRequest;
+type terms_BulkRowRefusal = BulkRowRefusal;
 type terms_ClearTermsResponse = ClearTermsResponse;
+type terms_CreateTermByNameRequest = CreateTermByNameRequest;
+type terms_CreateTermInput = CreateTermInput;
+type terms_CreateTermInputWithPlainFeatures = CreateTermInputWithPlainFeatures;
 type terms_CreateTermRequest = CreateTermRequest;
 type terms_DeleteTermReport = DeleteTermReport;
 type terms_FeatureChangeDto = FeatureChangeDto;
@@ -34426,7 +35410,7 @@ type terms_VersionDiffDto = VersionDiffDto;
 type terms_WitnessInstantiationDto = WitnessInstantiationDto;
 type terms_WitnessProofDto = WitnessProofDto;
 declare namespace terms {
-  export type { terms_BulkAddTermsRequest as BulkAddTermsRequest, terms_BulkAddTermsResponse as BulkAddTermsResponse, terms_ClearTermsResponse as ClearTermsResponse, terms_CreateTermRequest as CreateTermRequest, terms_DeleteTermReport as DeleteTermReport, terms_FeatureChangeDto as FeatureChangeDto, terms_ReferencedTermSummary as ReferencedTermSummary, terms_ResidualWitnessDto as ResidualWitnessDto, terms_ResiduationDto as ResiduationDto, terms_TermDto as TermDto, terms_TermOrigin as TermOrigin, terms_TermReferencesDisposition as TermReferencesDisposition, terms_TermReferrerDto as TermReferrerDto, terms_TermReferrersResponse as TermReferrersResponse, terms_TermResponse as TermResponse, terms_TermState as TermState, terms_TermVersionDto as TermVersionDto, terms_TermVersionsResponse as TermVersionsResponse, terms_UpdateTermRequest as UpdateTermRequest, terms_ValidatedTermResponse as ValidatedTermResponse, terms_ValidatedUnifyResponse as ValidatedUnifyResponse, terms_VersionDiffDto as VersionDiffDto, terms_WitnessInstantiationDto as WitnessInstantiationDto, terms_WitnessProofDto as WitnessProofDto };
+  export type { terms_BulkAddTermsRequest as BulkAddTermsRequest, terms_BulkAddTermsResponse as BulkAddTermsResponse, terms_BulkCreateTermsRequest as BulkCreateTermsRequest, terms_BulkRowRefusal as BulkRowRefusal, terms_ClearTermsResponse as ClearTermsResponse, terms_CreateTermByNameRequest as CreateTermByNameRequest, terms_CreateTermInput as CreateTermInput, terms_CreateTermInputWithPlainFeatures as CreateTermInputWithPlainFeatures, terms_CreateTermRequest as CreateTermRequest, terms_DeleteTermReport as DeleteTermReport, terms_FeatureChangeDto as FeatureChangeDto, terms_ReferencedTermSummary as ReferencedTermSummary, terms_ResidualWitnessDto as ResidualWitnessDto, terms_ResiduationDto as ResiduationDto, terms_TermDto as TermDto, terms_TermOrigin as TermOrigin, terms_TermReferencesDisposition as TermReferencesDisposition, terms_TermReferrerDto as TermReferrerDto, terms_TermReferrersResponse as TermReferrersResponse, terms_TermResponse as TermResponse, terms_TermState as TermState, terms_TermVersionDto as TermVersionDto, terms_TermVersionsResponse as TermVersionsResponse, terms_UpdateTermRequest as UpdateTermRequest, terms_ValidatedTermResponse as ValidatedTermResponse, terms_ValidatedUnifyResponse as ValidatedUnifyResponse, terms_VersionDiffDto as VersionDiffDto, terms_WitnessInstantiationDto as WitnessInstantiationDto, terms_WitnessProofDto as WitnessProofDto };
 }
 
 /**
@@ -34728,14 +35712,50 @@ interface BackwardChainResponse {
 interface ForwardChainRequest {
     /** Initial facts (optional — uses existing facts if not provided). */
     initialFacts?: TermInputDto[];
-    /** Whether to persist derived facts to storage. */
-    persistDerived?: boolean;
+    /**
+     * KEEP the run's derivations resident in the tenant's store instead of
+     * rolling them back, so a later `MATCH` reads them.
+     *
+     * @remarks
+     * Default `false`, and "ephemeral" means ROLLED BACK rather than merely
+     * unwritten: the engine removes every wrapper and inner copy the run created
+     * before it answers. So a default run reports a `derivedCount` and leaves the
+     * store exactly as it found it — **forward chaining is not a repair door**.
+     * To re-materialise a tenant use OSFQL `CHAIN;` or
+     * {@link AdminClient.rebuildDerivedFacts}.
+     *
+     * Not durable, and never was: the engine's old write stored only the
+     * `meta.clause` wrapper of each conclusion and never the inner ground copy a
+     * reader returns, so nothing survived a restart. That write is gone, and the
+     * flag now says what it always did. Named `persistDerived` until the engine
+     * renamed the wire field to `keep_derived`.
+     */
+    keepDerived?: boolean;
     /** Whether to include provenance tags (confidence scores) in the response. */
     enableProvenanceTags?: boolean;
     /** Maximum number of derivation iterations. */
     maxIterations?: number;
     /** Maximum number of facts to derive. */
     maxFacts?: number;
+    /**
+     * A server-side deadline for this derivation, in milliseconds.
+     *
+     * @remarks
+     * The chainer checks it cooperatively — at every fixpoint-iteration boundary,
+     * at every rule application, and inside each rule's own candidate loop — and
+     * the route answers `504` when it passes. Clamped by the engine's
+     * `OSFKB_FC_TIMEOUT_SECS`.
+     *
+     * Omitted means that backstop (300 s by default), which is deliberately
+     * longer than the safe-method one: a full materialisation over a large tenant
+     * legitimately takes longer than a `GET` handler. `0` is the explicit opt-out.
+     *
+     * A deadline does not change what the run keeps — {@link keepDerived} stays
+     * the single switch. A truncated `keepDerived: true` run keeps the partial
+     * derivation it reached, so a re-run continues from it; a truncated default
+     * run is rolled back and keeps nothing. The `504` body says which happened.
+     */
+    timeoutMs?: number | null;
     /**
      * Emit W3C PROV-O lineage for this run (default: `false`).
      *
@@ -34763,8 +35783,15 @@ interface ForwardChainResponse {
     totalFacts: number;
     /** Materialization time in milliseconds. */
     materializationTimeMs: number;
-    /** Number of derived facts persisted (only when persist_derived=true). */
-    persistedCount?: number;
+    /**
+     * Derivations this run KEPT in the tenant's store.
+     *
+     * @remarks
+     * Non-zero only when the request carried `keepDerived: true`, since a default
+     * run rolls its output back. Counts `meta.clause` wrappers, which is one per
+     * conclusion.
+     */
+    keptCount?: number;
     /** Provenance tags for derived facts (only present when `enable_provenance_tags` was true). */
     provenanceTags?: ProvenanceTagDto[];
 }
@@ -35763,6 +36790,84 @@ declare namespace inference {
   export type { inference_AddFactRequest as AddFactRequest, inference_AddFactResponse as AddFactResponse, inference_AddRuleRequest as AddRuleRequest, inference_AddRuleResponse as AddRuleResponse, inference_AllenRelation as AllenRelation, inference_BackwardChainRequest as BackwardChainRequest, inference_BackwardChainResponse as BackwardChainResponse, inference_BayesianEffectDto as BayesianEffectDto, inference_BayesianPredictRequest as BayesianPredictRequest, inference_BayesianPredictResponse as BayesianPredictResponse, inference_BindingDto as BindingDto, inference_BulkAddFactsRequest as BulkAddFactsRequest, inference_BulkAddFactsResponse as BulkAddFactsResponse, inference_BulkAddRulesRequest as BulkAddRulesRequest, inference_BulkAddRulesResponse as BulkAddRulesResponse, inference_BulkFuzzyProveRequest as BulkFuzzyProveRequest, inference_BulkFuzzyProveResponse as BulkFuzzyProveResponse, inference_BulkRetractTermsRequest as BulkRetractTermsRequest, inference_BulkRetractTermsResponse as BulkRetractTermsResponse, inference_ClearFactsResponse as ClearFactsResponse, inference_ConstraintInputDto as ConstraintInputDto, inference_CreateGoalRequest as CreateGoalRequest, inference_CreateGoalResponse as CreateGoalResponse, inference_DeleteGoalResponse as DeleteGoalResponse, inference_DraftRulesRequest as DraftRulesRequest, inference_DraftRulesResponse as DraftRulesResponse, inference_FactConfidenceEntry as FactConfidenceEntry, inference_ForwardChainRequest as ForwardChainRequest, inference_ForwardChainResponse as ForwardChainResponse, inference_FuzzyProveRequest as FuzzyProveRequest, inference_FuzzyProveResponse as FuzzyProveResponse, inference_GetFactsResponse as GetFactsResponse, inference_GetRulesResponse as GetRulesResponse, inference_GoalDto as GoalDto, inference_GoalSummaryDto as GoalSummaryDto, inference_GuardOp as GuardOp, inference_HomoiconicSubstitutionDto as HomoiconicSubstitutionDto, inference_ListGoalsResponse as ListGoalsResponse, inference_LiteralInputDto as LiteralInputDto, inference_LogOddsAntecedentContributionDto as LogOddsAntecedentContributionDto, inference_LogOddsScoreDecompositionDto as LogOddsScoreDecompositionDto, inference_LogOddsWitnessDto as LogOddsWitnessDto, inference_MetaSortsResponse as MetaSortsResponse, inference_NafProveRequest as NafProveRequest, inference_NafProveResponse as NafProveResponse, inference_ProofDto as ProofDto, inference_ProofKind as ProofKind, inference_ProvenanceTagDto as ProvenanceTagDto, inference_ReplaceRuleResponse as ReplaceRuleResponse, inference_RuleAggregatorDto as RuleAggregatorDto, inference_RuleCertificationDelta as RuleCertificationDelta, inference_RuleDerivationsDisposition as RuleDerivationsDisposition, inference_RuleDraftClarificationQuestionDto as RuleDraftClarificationQuestionDto, inference_RuleDraftDto as RuleDraftDto, inference_RuleEntryDto as RuleEntryDto, inference_RuleNotWithdrawable as RuleNotWithdrawable, inference_RuleOrigin as RuleOrigin, inference_RuleTermDraftDto as RuleTermDraftDto, inference_RuleWithdrawalReport as RuleWithdrawalReport, inference_SolutionDto as SolutionDto, inference_TaggedDerivedFact as TaggedDerivedFact, inference_TaggedForwardChainRequest as TaggedForwardChainRequest, inference_TaggedForwardChainResponse as TaggedForwardChainResponse };
 }
 
+/**
+ * Request to align a domain ontology against one or more upper ontologies.
+ *
+ * @remarks
+ * Sent to `POST /api/v1/ontology/align`. Wire format is snake_case
+ * (`domain_owl`).
+ */
+interface AlignOntologyRequest {
+    /** Domain ontology to align, as OWL/RDF-XML. */
+    domainOwl: string;
+    /** Upper ontologies to align against. Defaults to `["BFO"]` when empty. */
+    targets?: string[];
+}
+/**
+ * A confirmed SKOS correspondence from a domain class to an upper-ontology class.
+ */
+interface AlignmentMatchDto {
+    /** Domain sort name. */
+    domainSort: string;
+    /** SKOS relation: `exactMatch` / `broadMatch` / `narrowMatch` / `closeMatch`. */
+    matchType: string;
+    /** Upper-ontology class CURIE (e.g. the BFO IRI's CURIE form). */
+    targetCurie: string;
+    /** Upper-ontology class label. */
+    targetLabel: string;
+}
+/**
+ * Two upper-ontology candidates a domain class cannot map to simultaneously
+ * (their lattice meet is ⊥ — e.g. disjoint BFO branches).
+ */
+interface AlignmentConflictDto {
+    /** Domain sort name whose candidates conflict. */
+    domainSort: string;
+    /** The kept (higher-scored) candidate CURIE. */
+    targetA: string;
+    /** The rejected, incompatible candidate CURIE. */
+    targetB: string;
+}
+/**
+ * A SKOS external-ontology alignment attached to a sort.
+ *
+ * @remarks
+ * Populated by the upper-ontology aligner so each correspondence is a live,
+ * queryable property of the sort rather than a separate static export.
+ */
+interface ExternalMatchDto {
+    /** SKOS mapping relation: `exactMatch` | `closeMatch` | `broadMatch` | `narrowMatch`. */
+    matchType: string;
+    /** CURIE of the aligned external concept (e.g. `obo:BFO_0000023`). */
+    ontologyId: string;
+    /** How the match was discovered: `grounding` | `manual` | `import` | `inferred`. */
+    source: string;
+}
+/**
+ * Response from an ontology-alignment run.
+ */
+interface AlignOntologyResponse {
+    /** Surfaced ⊥-conflicts among proposed candidates. */
+    conflicts: AlignmentConflictDto[];
+    /** Number of domain sorts considered. */
+    domainSorts: number;
+    /** The MAPPING artifact as Turtle (`skos:*` + `kortexya:confidence`). */
+    mappingTtl: string;
+    /** Confirmed SKOS correspondences. */
+    matches: AlignmentMatchDto[];
+    /** Number of upper-ontology target sorts indexed. */
+    targetSorts: number;
+}
+
+type ontologyAlignment_AlignOntologyRequest = AlignOntologyRequest;
+type ontologyAlignment_AlignOntologyResponse = AlignOntologyResponse;
+type ontologyAlignment_AlignmentConflictDto = AlignmentConflictDto;
+type ontologyAlignment_AlignmentMatchDto = AlignmentMatchDto;
+type ontologyAlignment_ExternalMatchDto = ExternalMatchDto;
+declare namespace ontologyAlignment {
+  export type { ontologyAlignment_AlignOntologyRequest as AlignOntologyRequest, ontologyAlignment_AlignOntologyResponse as AlignOntologyResponse, ontologyAlignment_AlignmentConflictDto as AlignmentConflictDto, ontologyAlignment_AlignmentMatchDto as AlignmentMatchDto, ontologyAlignment_ExternalMatchDto as ExternalMatchDto };
+}
+
 /**
  * How a sort was created. Tagged union discriminated by `"type"`.
  *
@@ -35906,6 +37011,14 @@ interface FeatureDescriptorDto {
      * Enforced only when the sort's {@link CreateSortRequest.worldMode} is
      * `closed`. On an open sort a missing feature residuates — it is
      * unconstrained, not absent — so `required: true` there constrains nothing.
+     *
+     * This is the same statement as `minCount >= 1` at a coarser resolution,
+     * and the engine derives it: measured, a descriptor sent with
+     * `{ minCount: 2, required: false }` reads back `"required": true`. The
+     * implication runs one way only — `required: true` alone stores no
+     * `minCount` — and the contradictory pair
+     * `{ required: true, minCount: 0 }` is refused with a `400`. See
+     * {@link FeatureDescriptorDto.minCount}.
      */
     required: boolean;
     /** Optional constraint on the feature's value. */
@@ -35925,7 +37038,140 @@ interface FeatureDescriptorDto {
      * later join is ambiguous.
      */
     key?: boolean;
+    /**
+     * The same target, named instead of identified — how an object relation is
+     * declared when the target sort's id does not exist yet.
+     *
+     * @remarks
+     * Resolved only by `POST /api/v1/sorts/bulk`
+     * ({@link SortsClient.bulkCreateSorts}), which mints its ids server-side:
+     * a relation between two sorts of the SAME batch has no id its caller
+     * could write into {@link FeatureDescriptorDto.expectedSort}. The name is
+     * matched against the batch's own name → id map and the tenant's existing
+     * sorts.
+     *
+     * Measured — one bulk request declaring `Invoice.issued_to` with
+     * `expectedSortName: 'Client'` alongside a `Client` definition reads back
+     * `"expected_sort": "7e764fb0-…"`, the id of the `Client` the same batch
+     * created. A name that resolves to nothing is reported in the response's
+     * `errors` and the feature is left unbound; it is never silently dropped.
+     *
+     * `expectedSort` wins when both are given.
+     */
+    expectedSortName?: string | null;
+    /**
+     * The least number of values this feature must hold — the bound `required`
+     * cannot express.
+     *
+     * @remarks
+     * **`minCount` binds only under a closed world.** Measured against the
+     * engine on a sort declaring `lines` with `minCount: 2, maxCount: 3`:
+     *
+     * | values written | `worldMode: 'open'` | `worldMode: 'closed'` |
+     * | --- | --- | --- |
+     * | 0 | 201 created | 422 `required feature 'lines' is missing` |
+     * | 1 | 201 created | 422 `feature 'lines' holds 1 values, below its declared minimum of 2` |
+     * | 2 | 201 created | 201 created |
+     *
+     * On an open sort a short or absent feature RESIDUATES — it is
+     * unconstrained, not wrong — so a schema that means its minimum must also
+     * say {@link CreateSortRequest.worldMode} `closed`.
+     * {@link FeatureDescriptorDto.maxCount} needs no such help.
+     *
+     * **A non-zero `minCount` IS {@link FeatureDescriptorDto.required}.** The
+     * engine keeps the two consistent in one direction only: measured,
+     * `{ minCount: 2, required: false }` reads back `"required": true`, and
+     * `{ minCount: 2 }` with no `required` also reads back `"required": true`.
+     * The reverse does not hold — `{ required: true }` alone reads back with
+     * NO `minCount` at all. And `{ required: true, minCount: 0 }` is refused
+     * with a `400`: *"a feature that may hold no value at all is NOT
+     * required"*.
+     *
+     * A `minCount` above {@link FeatureDescriptorDto.maxCount} is refused with
+     * a `400` — *"declares min_count 5 above max_count 2, so no term could
+     * ever satisfy it"* — rather than stored unsatisfiable.
+     *
+     * A read answers `0` here whenever only `maxCount` was declared: measured,
+     * `{ maxCount: 3 }` reads back `{ min_count: 0, max_count: 3 }`.
+     *
+     * ⚠️ Enforcement is gated on
+     * {@link FeatureDescriptorDto.cardinalityOrigin} — an `inferred` bound
+     * refuses nothing. See that field.
+     */
+    minCount?: number | null;
+    /**
+     * The greatest number of values this feature may hold.
+     *
+     * @remarks
+     * **`maxCount` binds under BOTH world modes**, unlike
+     * {@link FeatureDescriptorDto.minCount}. Measured on a sort declaring
+     * `lines` with `minCount: 2, maxCount: 3`, writing four values is refused
+     * identically on an open and on a closed sort:
+     * `422 Constraint violation: Feature 'lines' holds 4 values, above its
+     * declared maximum of 3`. Over-supply is a contradiction whatever the
+     * world assumption; under-supply is only missing information.
+     *
+     * `maxCount: 0` is accepted and reads back `{ min_count: 0, max_count: 0 }`
+     * — a feature declared to hold no value.
+     *
+     * Omitting it is the unbounded maximum; the OSFQL spelling of the pair is
+     * `@card(min)` / `@card(min, max)`, with `*` for unbounded.
+     *
+     * ⚠️ Enforcement is gated on
+     * {@link FeatureDescriptorDto.cardinalityOrigin} — an `inferred` bound
+     * refuses nothing. See that field.
+     */
+    maxCount?: number | null;
+    /**
+     * Where the bounds above came from, and therefore whether a write may be
+     * refused for breaking them.
+     *
+     * @remarks
+     * A bound sent without this field is `declared`: measured, a create
+     * carrying `minCount: 2, maxCount: 3` and no origin reads back
+     * `"cardinality_origin": "declared"`, and the write path then enforces it.
+     *
+     * `inferred` records a bound read out of an extracted axiom. It is
+     * carried, exported and diffed — and it **refuses nothing**. Measured on a
+     * `closed` sort declaring `lines` with `minCount: 2, maxCount: 3,
+     * cardinalityOrigin: 'inferred'`, both a one-value write and a four-value
+     * write answer `201`, where the same sort with a `declared` bound refuses
+     * each. The derivation of `required` is off too: that descriptor reads
+     * back `"required": false` beside `"min_count": 2`.
+     *
+     * Sending it back unchanged is the point of the field. The ordinary way to
+     * amend a sort is read → edit → create, and without the origin beside the
+     * bound that round trip would promote every bound the extraction pipeline
+     * inferred into a declared one, and start refusing the ingestion that
+     * wrote it.
+     *
+     * A word outside the two is refused with a `422` naming both.
+     */
+    cardinalityOrigin?: CardinalityOriginDto | null;
+    /**
+     * Custom OWL annotations on this feature — `isIdentifier`, `unit`,
+     * `enumValues`, and whatever else the tenant's model needs.
+     *
+     * @remarks
+     * The keys are DATA, so they survive the request body's snake_case
+     * transform untouched. Measured: a create carrying
+     * `annotations: { isIdentifier: 'true', unit: 'none' }` reads back
+     * `"annotations": {"isIdentifier": "true", "unit": "none"}` — the
+     * camelCase key intact.
+     *
+     * `key: true` is stored as the `unique` annotation, so this map echoes it.
+     */
+    annotations?: Record<string, string>;
 }
+/**
+ * Where a feature's multiplicity bounds came from.
+ *
+ * @remarks
+ * `declared` bounds are enforced on every write; `inferred` bounds are
+ * carried and reported but refuse nothing. See
+ * {@link FeatureDescriptorDto.cardinalityOrigin}.
+ */
+type CardinalityOriginDto = 'declared' | 'inferred';
 /**
  * Inter-feature ordering constraint within a sort.
  *
@@ -36009,6 +37255,63 @@ interface SortDto {
      * the committed {@link SortDto.name}.
      */
     pluginLocalName?: string | null;
+    /**
+     * Synonyms (`skos:altLabel`) — the other words people use for this
+     * concept, each of which resolves to it in label search, extraction and NL
+     * query.
+     *
+     * @remarks
+     * Written by {@link BulkSortDefinition.altLabels} and curated by
+     * {@link PatchSortRequest.altLabels} / {@link PatchSortRequest.addAltLabels}.
+     */
+    altLabels?: string[];
+    /**
+     * Search-only labels (`skos:hiddenLabel`) — misspellings, abbreviations,
+     * legacy terms. They resolve like synonyms but are never displayed.
+     */
+    hiddenLabels?: string[];
+    /**
+     * Usage guidance (`skos:scopeNote`) — when to reach for this concept
+     * rather than a neighbouring one. The disambiguator for near-homonyms.
+     */
+    scopeNote?: string | null;
+    /** Associative links (`skos:related`) — sort ids, non-hierarchical. */
+    related?: string[];
+    /**
+     * The ONE defining formula of a *defined* sort, rendered
+     * (`mod_3∘id(day) = 1`). `undefined` for a nominal sort.
+     *
+     * @remarks
+     * Without it a client reading a generated class can only guess its meaning
+     * from the name.
+     */
+    definition?: string | null;
+    /**
+     * Formulas observed coextensive with {@link SortDto.definition} on some
+     * corpus, each with the number of examples it held over.
+     *
+     * @remarks
+     * These are equivalence **hypotheses** a curator confirms — never
+     * identities the engine asserts.
+     */
+    coextensive?: CoextensiveDefinitionDto[];
+    /**
+     * SKOS external-ontology alignments (BFO/CCO and the like) attached to this
+     * sort by the upper-ontology aligner.
+     */
+    externalMatches?: ExternalMatchDto[];
+    /**
+     * Defined (functional) features — `feature = function(paths)`, computed
+     * from the term rather than asserted on it, rendered one per entry.
+     */
+    featureEquations?: string[];
+}
+/** A formula found coextensive with a sort's definition, and its evidence. */
+interface CoextensiveDefinitionDto {
+    /** The alternative formula, rendered. */
+    definition: string;
+    /** How many examples the coincidence was observed over. */
+    exampleCount: number;
 }
 /**
  * Response wrapper for sort endpoints.
@@ -36020,13 +37323,25 @@ interface SortDto {
 interface SortResponse {
     /** The sort. */
     sort: SortDto;
+    /**
+     * Residuated work released by this write — present only when a proposed
+     * sort was approved and suspensions were waiting on it.
+     */
+    wokenResiduations?: number | null;
 }
 /** Response for sort list operations. */
 interface SortListResponse {
     /** List of sorts. */
     sorts: SortDto[];
-    /** Total count. */
+    /**
+     * Sorts in **this** response — not the tenant total when pagination is
+     * active. Use {@link SortListResponse.total} for that.
+     */
     count: number;
+    /** Total sorts the tenant owns after filters, across all pages. */
+    total?: number;
+    /** Offset of the first sort in this response. */
+    offset?: number;
 }
 /**
  * Request to create a new sort.
@@ -36113,6 +37428,13 @@ interface BulkSortDefinition {
     features?: FeatureDescriptorDto[];
     /** Alternative labels / synonyms (e.g., HPO synonyms for semantic matching). */
     altLabels?: string[];
+    /**
+     * Search-only labels (`skos:hiddenLabel`) — misspellings, abbreviations,
+     * legacy terms. They resolve like synonyms but are never displayed.
+     */
+    hiddenLabels?: string[];
+    /** Usage guidance (`skos:scopeNote`) — when to reach for this concept. */
+    scopeNote?: string | null;
     /** Human-readable description. */
     description?: string | null;
     /** The world assumption for this sort — `open` (default) or `closed`. */
@@ -36152,6 +37474,12 @@ type BulkSortErrorKind =
  * existing sort as it was — read `sortCreated`, not the kind alone.
  */
  | 'unsatisfiable_declaration'
+/**
+ * A feature declares an `expectedTypeHint` this engine does not know, so
+ * every term written with that feature would be refused whatever its value.
+ * The message enumerates the hints the engine does know.
+ */
+ | 'unknown_type_hint'
 /** A parent this batch never created: a cycle, or a parent itself refused. */
  | 'unresolved_parent'
 /**
@@ -36717,6 +38045,41 @@ interface SearchSortsResponse {
     matches: SearchSortsMatch[];
 }
 /** Which sorts `GET /api/v1/sorts/schema` renders. */
+/**
+ * The window and the filters over `GET /api/v1/sorts/tenant/{id}`.
+ *
+ * @remarks
+ * A production tenant can own 1 M+ sorts (~500 MB uncompressed), which a
+ * single response reliably fails to deliver — so `limit` + `offset` are how
+ * a client streams the listing, and {@link SortListResponse.total} is how it
+ * knows when to stop.
+ */
+interface ListSortsQuery {
+    /** Max sorts to return. Omitted means no cap. */
+    limit?: number;
+    /** Zero-based index of the first sort returned. */
+    offset?: number;
+    /**
+     * Include system-defined sorts (`Thing`, `Person`, …).
+     *
+     * @remarks
+     * Omitted defaults to false for an ordinary caller and true for a
+     * reserved-write-exempt one (`policy_compiler` / `platform_admin`). An
+     * explicit `false` is honoured for every caller.
+     */
+    includeSystem?: boolean;
+    /** Only sorts an LLM extracted. */
+    llmExtracted?: boolean;
+    /** Only sorts flagged for human review. */
+    needsReview?: boolean;
+    /**
+     * Only sorts whose name starts with one of these prefixes.
+     *
+     * @remarks
+     * Comma-joined onto the wire, so several prefixes cost one request.
+     */
+    namePrefix?: string[];
+}
 interface SortsSchemaQuery {
     /** Only sorts flagged for human review. */
     needsReview?: boolean;
@@ -36785,6 +38148,8 @@ type sorts_BulkSetSimilaritiesResponse = BulkSetSimilaritiesResponse;
 type sorts_BulkSortDefinition = BulkSortDefinition;
 type sorts_BulkSortError = BulkSortError;
 type sorts_BulkSortErrorKind = BulkSortErrorKind;
+type sorts_CardinalityOriginDto = CardinalityOriginDto;
+type sorts_CoextensiveDefinitionDto = CoextensiveDefinitionDto;
 type sorts_ComputeGlbResponse = ComputeGlbResponse;
 type sorts_ComputeLubResponse = ComputeLubResponse;
 type sorts_ConstraintDto = ConstraintDto;
@@ -36811,6 +38176,7 @@ type sorts_LearnedSimilarityDto = LearnedSimilarityDto;
 type sorts_LearnedSimilarityListResponse = LearnedSimilarityListResponse;
 type sorts_LearnedSimilarityProvenanceDto = LearnedSimilarityProvenanceDto;
 type sorts_LearnedSimilarityStatusDto = LearnedSimilarityStatusDto;
+type sorts_ListSortsQuery = ListSortsQuery;
 type sorts_LubRequest = LubRequest;
 type sorts_LubResponse = LubResponse;
 type sorts_PatchSortFeatureRequest = PatchSortFeatureRequest;
@@ -36845,7 +38211,7 @@ type sorts_SortsSchemaQuery = SortsSchemaQuery;
 type sorts_UpdateReviewStatusRequest = UpdateReviewStatusRequest;
 type sorts_WorldModeDto = WorldModeDto;
 declare namespace sorts {
-  export type { sorts_ApproveLearnedSimilarityRequest as ApproveLearnedSimilarityRequest, sorts_ApproveLearnedSimilarityResponse as ApproveLearnedSimilarityResponse, sorts_BoundConstraintDto as BoundConstraintDto, sorts_BulkCreateSortsRequest as BulkCreateSortsRequest, sorts_BulkCreateSortsResponse as BulkCreateSortsResponse, sorts_BulkSetSimilaritiesRequest as BulkSetSimilaritiesRequest, sorts_BulkSetSimilaritiesResponse as BulkSetSimilaritiesResponse, sorts_BulkSortDefinition as BulkSortDefinition, sorts_BulkSortError as BulkSortError, sorts_BulkSortErrorKind as BulkSortErrorKind, sorts_ComputeGlbResponse as ComputeGlbResponse, sorts_ComputeLubResponse as ComputeLubResponse, sorts_ConstraintDto as ConstraintDto, sorts_CreateSortRequest as CreateSortRequest, sorts_DecodeGlbResponse as DecodeGlbResponse, sorts_DeleteSortResponse as DeleteSortResponse, sorts_DeleteSortRulesDisposition as DeleteSortRulesDisposition, sorts_DeleteSortTermsDisposition as DeleteSortTermsDisposition, sorts_DeprecateSortRequest as DeprecateSortRequest, sorts_EquivalenceClassDto as EquivalenceClassDto, sorts_FeatureDescriptorDto as FeatureDescriptorDto, sorts_GetEquivalenceClassesResponse as GetEquivalenceClassesResponse, sorts_GetFuzzySubsumptionRequest as GetFuzzySubsumptionRequest, sorts_GetFuzzySubsumptionResponse as GetFuzzySubsumptionResponse, sorts_GetPreorderDegreeRequest as GetPreorderDegreeRequest, sorts_GetPreorderDegreeResponse as GetPreorderDegreeResponse, sorts_GetSortSimilarityRequest as GetSortSimilarityRequest, sorts_GetSortSimilarityResponse as GetSortSimilarityResponse, sorts_GlbRequest as GlbRequest, sorts_GlbResponse as GlbResponse, sorts_LearnSortSimilaritiesRequest as LearnSortSimilaritiesRequest, sorts_LearnSortSimilaritiesResponse as LearnSortSimilaritiesResponse, sorts_LearnedSimilarityDto as LearnedSimilarityDto, sorts_LearnedSimilarityListResponse as LearnedSimilarityListResponse, sorts_LearnedSimilarityProvenanceDto as LearnedSimilarityProvenanceDto, sorts_LearnedSimilarityStatusDto as LearnedSimilarityStatusDto, sorts_LubRequest as LubRequest, sorts_LubResponse as LubResponse, sorts_PatchSortFeatureRequest as PatchSortFeatureRequest, sorts_PatchSortRequest as PatchSortRequest, sorts_RejectLearnedSimilarityRequest as RejectLearnedSimilarityRequest, sorts_RejectLearnedSimilarityResponse as RejectLearnedSimilarityResponse, sorts_RemoveSortFeatureOptions as RemoveSortFeatureOptions, sorts_SearchSortsBy as SearchSortsBy, sorts_SearchSortsMatch as SearchSortsMatch, sorts_SearchSortsRequest as SearchSortsRequest, sorts_SearchSortsResponse as SearchSortsResponse, sorts_SetFuzzySubsumptionRequest as SetFuzzySubsumptionRequest, sorts_SetFuzzySubsumptionResponse as SetFuzzySubsumptionResponse, sorts_SetSortSimilarityRequest as SetSortSimilarityRequest, sorts_SetSortSimilarityResponse as SetSortSimilarityResponse, sorts_SimilarityEntryDto as SimilarityEntryDto, sorts_SortCompareOperator as SortCompareOperator, sorts_SortCompareRequest as SortCompareRequest, sorts_SortCompareResponse as SortCompareResponse, sorts_SortDto as SortDto, sorts_SortFeatureEditResponse as SortFeatureEditResponse, sorts_SortIndexStatusResponse as SortIndexStatusResponse, sorts_SortInfoDto as SortInfoDto, sorts_SortListResponse as SortListResponse, sorts_SortOriginDto as SortOriginDto, sorts_SortReferenceKind as SortReferenceKind, sorts_SortReferencingRuleDto as SortReferencingRuleDto, sorts_SortResponse as SortResponse, sorts_SortSimilarityResponse as SortSimilarityResponse, sorts_SortStatusDto as SortStatusDto, sorts_SortsSchemaQuery as SortsSchemaQuery, sorts_UpdateReviewStatusRequest as UpdateReviewStatusRequest, sorts_WorldModeDto as WorldModeDto };
+  export type { sorts_ApproveLearnedSimilarityRequest as ApproveLearnedSimilarityRequest, sorts_ApproveLearnedSimilarityResponse as ApproveLearnedSimilarityResponse, sorts_BoundConstraintDto as BoundConstraintDto, sorts_BulkCreateSortsRequest as BulkCreateSortsRequest, sorts_BulkCreateSortsResponse as BulkCreateSortsResponse, sorts_BulkSetSimilaritiesRequest as BulkSetSimilaritiesRequest, sorts_BulkSetSimilaritiesResponse as BulkSetSimilaritiesResponse, sorts_BulkSortDefinition as BulkSortDefinition, sorts_BulkSortError as BulkSortError, sorts_BulkSortErrorKind as BulkSortErrorKind, sorts_CardinalityOriginDto as CardinalityOriginDto, sorts_CoextensiveDefinitionDto as CoextensiveDefinitionDto, sorts_ComputeGlbResponse as ComputeGlbResponse, sorts_ComputeLubResponse as ComputeLubResponse, sorts_ConstraintDto as ConstraintDto, sorts_CreateSortRequest as CreateSortRequest, sorts_DecodeGlbResponse as DecodeGlbResponse, sorts_DeleteSortResponse as DeleteSortResponse, sorts_DeleteSortRulesDisposition as DeleteSortRulesDisposition, sorts_DeleteSortTermsDisposition as DeleteSortTermsDisposition, sorts_DeprecateSortRequest as DeprecateSortRequest, sorts_EquivalenceClassDto as EquivalenceClassDto, sorts_FeatureDescriptorDto as FeatureDescriptorDto, sorts_GetEquivalenceClassesResponse as GetEquivalenceClassesResponse, sorts_GetFuzzySubsumptionRequest as GetFuzzySubsumptionRequest, sorts_GetFuzzySubsumptionResponse as GetFuzzySubsumptionResponse, sorts_GetPreorderDegreeRequest as GetPreorderDegreeRequest, sorts_GetPreorderDegreeResponse as GetPreorderDegreeResponse, sorts_GetSortSimilarityRequest as GetSortSimilarityRequest, sorts_GetSortSimilarityResponse as GetSortSimilarityResponse, sorts_GlbRequest as GlbRequest, sorts_GlbResponse as GlbResponse, sorts_LearnSortSimilaritiesRequest as LearnSortSimilaritiesRequest, sorts_LearnSortSimilaritiesResponse as LearnSortSimilaritiesResponse, sorts_LearnedSimilarityDto as LearnedSimilarityDto, sorts_LearnedSimilarityListResponse as LearnedSimilarityListResponse, sorts_LearnedSimilarityProvenanceDto as LearnedSimilarityProvenanceDto, sorts_LearnedSimilarityStatusDto as LearnedSimilarityStatusDto, sorts_ListSortsQuery as ListSortsQuery, sorts_LubRequest as LubRequest, sorts_LubResponse as LubResponse, sorts_PatchSortFeatureRequest as PatchSortFeatureRequest, sorts_PatchSortRequest as PatchSortRequest, sorts_RejectLearnedSimilarityRequest as RejectLearnedSimilarityRequest, sorts_RejectLearnedSimilarityResponse as RejectLearnedSimilarityResponse, sorts_RemoveSortFeatureOptions as RemoveSortFeatureOptions, sorts_SearchSortsBy as SearchSortsBy, sorts_SearchSortsMatch as SearchSortsMatch, sorts_SearchSortsRequest as SearchSortsRequest, sorts_SearchSortsResponse as SearchSortsResponse, sorts_SetFuzzySubsumptionRequest as SetFuzzySubsumptionRequest, sorts_SetFuzzySubsumptionResponse as SetFuzzySubsumptionResponse, sorts_SetSortSimilarityRequest as SetSortSimilarityRequest, sorts_SetSortSimilarityResponse as SetSortSimilarityResponse, sorts_SimilarityEntryDto as SimilarityEntryDto, sorts_SortCompareOperator as SortCompareOperator, sorts_SortCompareRequest as SortCompareRequest, sorts_SortCompareResponse as SortCompareResponse, sorts_SortDto as SortDto, sorts_SortFeatureEditResponse as SortFeatureEditResponse, sorts_SortIndexStatusResponse as SortIndexStatusResponse, sorts_SortInfoDto as SortInfoDto, sorts_SortListResponse as SortListResponse, sorts_SortOriginDto as SortOriginDto, sorts_SortReferenceKind as SortReferenceKind, sorts_SortReferencingRuleDto as SortReferencingRuleDto, sorts_SortResponse as SortResponse, sorts_SortSimilarityResponse as SortSimilarityResponse, sorts_SortStatusDto as SortStatusDto, sorts_SortsSchemaQuery as SortsSchemaQuery, sorts_UpdateReviewStatusRequest as UpdateReviewStatusRequest, sorts_WorldModeDto as WorldModeDto };
 }
 
 /**
@@ -37045,11 +38411,52 @@ declare class SortsClient {
      */
     getSchema(query?: SortsSchemaQuery, requestOptions?: RequestOptions): Promise<string>;
     /**
-     * List all sorts.
+     * List every sort the tenant owns.
      *
-     * @returns Array of sorts.
+     * @param requestOptions - Per-call transport overrides.
+     * @returns The sorts, each with its feature declarations.
+     * @throws {ApiError} When the engine refuses the request.
+     *
+     * @remarks
+     * This asks for the whole listing and keeps only the array. A production
+     * tenant can own 1 M+ sorts (~500 MB uncompressed), which one response
+     * cannot deliver — use {@link SortsClient.listSortsPage} to window it, to
+     * filter it, or to read the `total` that says when to stop.
+     *
+     * @example
+     * ```typescript
+     * const sorts = await client.sorts.listSorts();
+     * ```
      */
     listSorts(requestOptions?: RequestOptions): Promise<SortDto[]>;
+    /**
+     * List the tenant's sorts, keeping the envelope — `count`, `total` and
+     * `offset` beside the page.
+     *
+     * @param query - The window and filters over the listing.
+     * @param requestOptions - Per-call transport overrides.
+     * @returns The page, its length, the tenant's filtered total and the
+     *   offset the page starts at.
+     * @throws {ApiError} When the engine refuses the request.
+     *
+     * @remarks
+     * `count` is the length of THIS page; `total` is what the tenant owns after
+     * filters, across all pages. Measured against the engine on a tenant
+     * holding three sorts, `GET /api/v1/sorts/tenant/{id}` answers
+     * `{"count":3,"total":3,"offset":0}`.
+     *
+     * @example
+     * ```typescript
+     * let offset = 0;
+     * for (;;) {
+     *   const page = await client.sorts.listSortsPage({ limit: 500, offset });
+     *   consume(page.sorts);
+     *   offset += page.count;
+     *   if (page.total === undefined || offset >= page.total) break;
+     * }
+     * ```
+     */
+    listSortsPage(query?: ListSortsQuery, requestOptions?: RequestOptions): Promise<SortListResponse>;
     /**
      * Bulk-create sorts with name-based parent references.
      *
@@ -37401,9 +38808,9 @@ declare class Terms<SecurityDataType = unknown> {
      * @request POST:/api/v1/terms
      * @secure
      */
-    addTerm: (data: CreateTermRequest$1, params?: RequestParams) => Promise<HttpResponse<TermResponse$1, void>>;
+    addTerm: (data: CreateTermInput$1, params?: RequestParams) => Promise<HttpResponse<TermResponse$1, void>>;
     /**
-     * @description Creates multiple terms in a single operation for efficiency. This is optimized for high-volume data loading scenarios and skips individual witness validation (constraint propagation runs once at the end). # Performance - Terms are added to the domain store in a single lock acquisition - Constraint propagation runs once after all terms are added - Much faster than calling add_term N times # Declarations and all-or-nothing (#238, #239) Every entry is held to the same declarations as `POST /terms`, with the same `422`. One refusal — a declaration violation or a bound-constraint violation — refuses the WHOLE batch and puts the store and the facade back: fresh ids removed, coreferenced entities restored to their pre-batch description. A batch may reference the client-minted ids it is itself creating: the resolver is the resident store unioned with the batch's own ids. When such an id then coreferences through a `@key`, every designator of it in the same batch is rewritten to the entity it merged into — the reference names what the write actually produced, never an id the coreference removed. `term_ids` carries the EFFECTIVE id per request position — the created id, or the existing entity's id when the entry coreferenced through a `@key`. # Authorization Requires X-Tenant-Id header. The tenant_id is taken from the header.
+     * @description Creates multiple terms in a single operation for efficiency. This is optimized for high-volume data loading scenarios and skips individual witness validation (constraint propagation runs once at the end). # Performance - Terms are added to the domain store in a single lock acquisition - Constraint propagation runs once after all terms are added - Much faster than calling add_term N times # Declarations and all-or-nothing (#238, #239, #262) Every entry is held to the same declarations as `POST /terms`, with the same `422`. One refusal — a declaration violation or a bound-constraint violation — refuses the WHOLE batch and puts the store and the facade back: fresh ids removed, coreferenced entities restored to their pre-batch description. The refusal NAMES THE ROWS (#262): the body carries `errors[]`, one entry per refused row, each with its `index` in the request's `terms` array and the `feature` the refusal is about when it names one, so a client repairs the exact rows it sent instead of guessing which one a single-message refusal meant. `partial: true` (#271) writes the rows the checks did NOT refuse instead of refusing the batch for one of them. A real import holding one bad record had to be resent minus that record — a second full call, a second full round of constraint evaluation, and a window in which a survivor's reference target can be deleted between the two — although the engine already names every bad entry by index in one pass and therefore already knows which ones were fine. The answer is `201` when anything was written, with `term_ids` carrying one id per ACCEPTED row and the same `errors[]` beside it; `422` when every row was refused, because nothing was written and that is a refusal. ⛔ Two failures stay batch-wide under `partial`, because neither can be attributed to a row, and the flag does not pretend otherwise: the end-of-batch constraint propagation answers ONE `409` for the whole batch (`facade.process_events`), and a persistence failure reverts what the batch inserted (#239). `dry_run: true` (#262) runs every check the real write runs — conversion, declarations, coreference, events — and writes nothing: the store and the facade are put back inside the write lock, nothing persists, nothing is notified, no derivation is queued. A clean dry run answers `200` with the count the batch would have produced and NO `term_ids` (#268): the rollback has already discarded every id it minted for a fresh entry, and a second, real POST of the same body mints different ones — so the vector named nothing, in the very positions the field documents as storable. The ids that DO outlive a dry run are the entities a `@key` coreference would have merged into, and those are answered separately as `coreferenced_term_ids`. A refused dry run answers the same `errors[]` body the real write answers with. A batch may reference the client-minted ids it is itself creating: the resolver is the resident store unioned with the batch's own ids. When such an id then coreferences through a `@key`, every designator of it in the same batch is rewritten to the entity it merged into — the reference names what the write actually produced, never an id the coreference removed. On a real write `term_ids` carries the EFFECTIVE id per request position — the created id, or the existing entity's id when the entry coreferenced through a `@key`. It is ABSENT on a dry run. # Authorization Requires X-Tenant-Id header. The tenant_id is taken from the header.
      *
      * @tags terms
      * @name BulkAddTerms
@@ -37464,6 +38871,8 @@ declare class Terms<SecurityDataType = unknown> {
      * @secure
      */
     listTerms: (query?: {
+        /** Include the rule conclusions this process has materialised, each carrying `origin: derived` and `derived_by` (default true); send false for the asserted rows alone */
+        include_derived?: boolean;
         /**
          * Max terms to return; omit for all, hard-capped at 10000
          * @min 0
@@ -37474,7 +38883,7 @@ declare class Terms<SecurityDataType = unknown> {
          * @min 0
          */
         offset?: number;
-        /** Only terms of this exact sort; omit for every sort */
+        /** Only terms of this EXACT sort — a member of a subsort is not answered; omit for every sort */
         sort_name?: string;
     }, params?: RequestParams) => Promise<HttpResponse<TermListResponse$1, any>>;
     /**
@@ -37793,24 +39202,70 @@ interface OsfSearchResponse {
     stats: OsfSearchStatsDto;
 }
 /**
- * Response wrapper for term list queries (e.g., `findBySort`).
+ * A page of terms, with the size of the whole answer beside it.
  *
  * @remarks
- * The SDK unwraps this internally, returning `TermDto[]` to the caller.
+ * Returned as-is by {@link TermsClient.listTerms} and
+ * {@link QueryClient.findBySortPage}. Read {@link total} to page, never
+ * {@link count} — and read {@link note} before you tell a user an empty page
+ * means an empty sort.
  */
 interface TermListResponse {
-    /** Matching terms. */
+    /** The terms on this page. */
     terms: TermDto[];
     /**
-     * How many terms are in THIS page — not how many match in total.
+     * How many terms are on THIS page — always `terms.length`, never the size of
+     * the answer.
      *
      * @remarks
      * With no `limit` the two coincide, which is what made the old "Total count"
-     * reading look right. With `limit: 2` the engine answers `count: 2` at every
-     * offset, so treating it as a grand total stops a walk after one page.
-     * Measured against the live engine on 2026-09-11.
+     * doc look right. Measured against the live engine on 2026-09-18: a tenant
+     * holding 3 terms answered `GET /api/v1/terms?limit=1&offset=2` with
+     * `{"count":1,"total":3}`. Paging off `count` stops the walk after one page;
+     * page off {@link total}.
      */
     count: number;
+    /**
+     * How many terms the request matched BEFORE `offset` and `limit` — the size
+     * of the answer, and the number to page against.
+     *
+     * @remarks
+     * A counted size, never a search bound. Absent on a route that does not page
+     * (the namespace listings), so a caller that must page should treat
+     * `undefined` as "the endpoint does not report it" and fall back to the
+     * short-page rule, which is what {@link TermsClient.iterateTerms} does.
+     *
+     * ⚠️ `total: 0` is not proof of an empty sort. See {@link note}.
+     */
+    total?: number;
+    /**
+     * The engine explaining an answer a caller would otherwise misread — today,
+     * an EMPTY answer for a sort whose members exist only by derivation.
+     *
+     * @remarks
+     * `GET /api/v1/terms` and `POST /api/v1/query/by-sort` neither chain nor
+     * persist conclusions: they report the conclusions the process currently
+     * HOLDS. For a rule-conclusion sort in a freshly started process that set is
+     * empty, so the honest count is `0` — and `total: 0` off that route reads
+     * like an authoritative "this sort has no members", which is false. `note`
+     * is the engine saying so, and naming the routes that materialise the
+     * conclusions.
+     *
+     * So: when the page is empty, surface `note` instead of "no results". It is
+     * never an error, and never a substitute for one — ignore it and the rows
+     * beside it are still correct.
+     *
+     * Measured 2026-09-18. A tenant with sort `widget`, subsort
+     * `premium_widget`, one `widget` fact and the rule
+     * `widget(name: ?N) → premium_widget(name: ?N)`:
+     * `POST /api/v1/query/by-sort {"sort_name":"premium_widget"}` answered
+     * `{"terms":[],"count":0,"total":0,"note":"`premium_widget` is a rule
+     * conclusion sort: its members are derived. … An empty answer here does not
+     * mean the sort has no members."}`. `GET
+     * /api/v1/terms?sort_name=premium_widget` answered the same note. Before the
+     * rule existed, the same empty query carried no note.
+     */
+    note?: string;
 }
 /**
  * Response wrapper for unification queries (e.g., `findUnifiable`).
@@ -37873,6 +39328,26 @@ interface FindBySortRequest {
      * pass 0) for no cap.
      */
     limit?: number | null;
+    /**
+     * Zero-based index of the first term to return.
+     *
+     * @remarks
+     * Pages the same ordering `limit` cuts: the answer is ordered by term id
+     * BEFORE the window is applied, so page 2 neither repeats nor skips a row of
+     * page 1. Honoured with or without `limit`.
+     *
+     * Measured 2026-09-18 against a 2-member sort:
+     * `{"sort_name":"widget","include_derived":true}` answered ids
+     * `829ef5dc-…`, `d4f7a4f8-…` with `total: 2`; the same request plus
+     * `{"limit":1,"offset":1}` answered `d4f7a4f8-…` alone, still `total: 2`.
+     *
+     * Reachable only through {@link QueryClient.findBySortPage} —
+     * {@link QueryClient.findBySort} discards the envelope, so paging through it
+     * gives you a window you cannot tell the end of.
+     *
+     * @defaultValue `0`
+     */
+    offset?: number | null;
     /**
      * Answer with the rule-DERIVED shadows too.
      *
@@ -37978,165 +39453,6 @@ declare namespace query {
   export type { query_BySortQueryRequest as BySortQueryRequest, query_ConversationTurnDto as ConversationTurnDto, query_DiscoveredRelationDto as DiscoveredRelationDto, query_FindBySortRequest as FindBySortRequest, MatchedEntityDto$1 as MatchedEntityDto, query_MissingInfoDto as MissingInfoDto, query_NlQueryMode as NlQueryMode, query_NlQueryRequest as NlQueryRequest, query_NlQueryResponse as NlQueryResponse, query_NlQueryResultItem as NlQueryResultItem, query_OsfSearchRequest as OsfSearchRequest, query_OsfSearchResponse as OsfSearchResponse, query_OsfSearchStatsDto as OsfSearchStatsDto, query_ResumptionOptionDto as ResumptionOptionDto, query_SuspendedQueryDto as SuspendedQueryDto, query_TermListResponse as TermListResponse, query_TermPatternDto as TermPatternDto, query_ToolCallInfo as ToolCallInfo, query_UnifiableQueryRequest as UnifiableQueryRequest, query_UnificationQueryResponse as UnificationQueryResponse, query_ValidateTermRequest as ValidateTermRequest, query_ValidatedUnifyRequest as ValidatedUnifyRequest };
 }
 
-/**
- * A format-agnostic psi-term produced by the `psi()` builder.
- *
- * @remarks
- * Can be passed to both term CRUD methods (converted to tagged `ValueDto` format)
- * and inference methods (converted to untagged `TermInputDto` format).
- * The SDK handles the conversion automatically based on which method receives it.
- *
- * Distinguished from plain objects by the `__psiTerm` brand field, which is
- * stripped before serialization.
- *
- * @example
- * ```typescript
- * // Works with term CRUD:
- * await client.terms.createTerm({ sortId, ownerId, features: { name: "Alice" } });
- *
- * // Works with inference:
- * await client.inference.addFact({ term: psi("person", { name: "Alice" }) });
- * ```
- */
-/**
- * A psi-term identified by sort name.
- */
-interface PsiTermInputByName {
-    /** @internal Brand field to distinguish from plain objects. Stripped before serialization. */
-    readonly __psiTerm: true;
-    /** Sort name for this term (resolved server-side). */
-    readonly sortName: string;
-    /** Features using plain JavaScript values. */
-    readonly features?: PlainFeatureMap;
-    /**
-     * Binder naming this term's own identity (`?C`), from {@link bind}.
-     *
-     * @remarks
-     * Only meaningful in an inference context, where it writes the OSFQL
-     * `?C: sort(...)` join.
-     */
-    readonly binding?: string;
-}
-/**
- * A psi-term identified by sort ID (UUID).
- */
-interface PsiTermInputById {
-    /** @internal Brand field to distinguish from plain objects. Stripped before serialization. */
-    readonly __psiTerm: true;
-    /** Sort ID (UUID) for this term. */
-    readonly sortId: string;
-    /** Features using plain JavaScript values. */
-    readonly features?: PlainFeatureMap;
-    /**
-     * Binder naming this term's own identity (`?C`), from {@link bind}.
-     *
-     * @remarks
-     * Only meaningful in an inference context, where it writes the OSFQL
-     * `?C: sort(...)` join.
-     */
-    readonly binding?: string;
-}
-/**
- * A format-agnostic psi-term produced by the `psi()` builder.
- *
- * @remarks
- * Exactly one of `sortName` or `sortId` is present — enforced by the union type.
- * Can be passed to both term CRUD methods (converted to tagged `ValueDto` format)
- * and inference methods (converted to untagged `TermInputDto` format).
- * The SDK handles the conversion automatically based on which method receives it.
- *
- * Distinguished from plain objects by the `__psiTerm` brand field, which is
- * stripped before serialization.
- *
- * @example
- * ```typescript
- * // Works with term CRUD:
- * await client.terms.createTerm({ sortId, ownerId, features: { name: "Alice" } });
- *
- * // Works with inference:
- * await client.inference.addFact({ term: psi("person", { name: "Alice" }) });
- * ```
- */
-type PsiTermInput = PsiTermInputByName | PsiTermInputById;
-/**
- * A constrained variable for use in inference contexts.
- *
- * @remarks
- * Created via the `constrained()` helper. Distinguished from plain arrays
- * by the `__constrainedVar` brand field, which is stripped before serialization.
- *
- * @example
- * ```typescript
- * psi("eligible", { score: constrained("?S", guard("gt", 700)) })
- * ```
- */
-interface ConstrainedPlainVar {
-    /** @internal Brand field. Stripped before serialization. */
-    readonly __constrainedVar: true;
-    /** Variable name (must start with "?"). */
-    readonly name: string;
-    /** Constraint as a TermInputDto or PsiTermInput. */
-    readonly constraint: TermInputDto | PsiTermInput;
-}
-/**
- * A plain JavaScript value that the SDK auto-converts to the correct wire format.
- *
- * @remarks
- * The SDK converts this to either tagged `ValueDto` or untagged `FeatureInputValueDto`
- * depending on which resource client method receives it:
- *
- * - `string` — string value (or variable if `?`-prefixed in inference context)
- * - `number` — integer if `Number.isInteger()`, real otherwise
- * - `boolean` — boolean value
- * - `null` — uninstantiated
- * - `PsiTermInput` — nested inline term (from `psi()` builder)
- * - `ConstrainedPlainVar` — constrained variable (from `constrained()` helper)
- * - `PlainFeatureValue[]` — list of values
- * - `ValueDto` — passthrough (already in tagged format)
- * - `FeatureInputValueDto` — passthrough (already in untagged format)
- *
- * Fuzzy and set values cannot be expressed as plain JS values. Use `Value.fuzzyScalar()`,
- * `Value.fuzzyNumber()`, or `Value.set()` directly — they pass through unchanged.
- */
-type PlainFeatureValue = string | number | boolean | null | PsiTermInput | ConstrainedPlainVar | PlainFeatureValue[] | ValueDto | FeatureInputValueDto;
-/**
- * A feature map using plain JavaScript values.
- *
- * @remarks
- * Pass this to resource client methods. The SDK converts to the appropriate
- * wire format (tagged or untagged) based on which method is called.
- *
- * @example
- * ```typescript
- * const features: PlainFeatureMap = {
- *   name: "Alice",
- *   age: 30,
- *   active: true,
- *   salary: null,  // uninstantiated
- * };
- * ```
- */
-type PlainFeatureMap = Record<string, PlainFeatureValue>;
-/**
- * Union of PsiTermInput or already-formatted TermInputDto.
- *
- * @remarks
- * Accepted by inference resource client methods that take term inputs.
- * If a `PsiTermInput` is passed, it is converted to `TermInputDto` internally.
- */
-type TermInputArg = PsiTermInput | TermInputDto;
-
-type plainValues_ConstrainedPlainVar = ConstrainedPlainVar;
-type plainValues_PlainFeatureMap = PlainFeatureMap;
-type plainValues_PlainFeatureValue = PlainFeatureValue;
-type plainValues_PsiTermInput = PsiTermInput;
-type plainValues_PsiTermInputById = PsiTermInputById;
-type plainValues_PsiTermInputByName = PsiTermInputByName;
-type plainValues_TermInputArg = TermInputArg;
-declare namespace plainValues {
-  export type { plainValues_ConstrainedPlainVar as ConstrainedPlainVar, plainValues_PlainFeatureMap as PlainFeatureMap, plainValues_PlainFeatureValue as PlainFeatureValue, plainValues_PsiTermInput as PsiTermInput, plainValues_PsiTermInputById as PsiTermInputById, plainValues_PsiTermInputByName as PsiTermInputByName, plainValues_TermInputArg as TermInputArg };
-}
-
 /**
  * Resource client for record operations (create, read, update, delete typed records).
  *
@@ -38155,8 +39471,32 @@ interface ListTermsQuery {
     limit?: number;
     /** Zero-based index of the first term (default 0). */
     offset?: number;
-    /** Only terms of this exact sort; omit for every sort. */
+    /**
+     * Only terms of this EXACT sort; omit for every sort.
+     *
+     * @remarks
+     * A member of a SUBSORT is not answered — this is an equality filter on the
+     * term's own sort, not a lattice browse. For the polymorphic browse (a sort
+     * and everything below it) use {@link QueryClient.findBySortPage}.
+     */
     sortName?: string;
+    /**
+     * Include the rule conclusions this process has materialised.
+     *
+     * @remarks
+     * ⚠️ The engine's default here is `true`, the OPPOSITE of
+     * {@link FindBySortRequest.includeDerived}. Omit this and you get the
+     * conclusions; send `false` for the asserted rows alone. Each conclusion
+     * carries {@link TermDto.origin} `'derived'` and, when the engine recorded
+     * one, {@link TermDto.derivedBy}.
+     *
+     * The route does not chain. It reports what the last chain left, so after a
+     * restart the derived half is empty until something chains again.
+     *
+     * @defaultValue `true` (the engine's default — the SDK sends nothing when
+     *   this is omitted)
+     */
+    includeDerived?: boolean;
 }
 declare class TermsClient {
     /** @internal */
@@ -38198,9 +39538,7 @@ declare class TermsClient {
      * });
      * ```
      */
-    createTerm(request: Omit<CreateTermRequest, 'features'> & {
-        features: Record<string, PlainFeatureValue>;
-    }, requestOptions?: RequestOptions): Promise<TermResponse>;
+    createTerm(request: CreateTermInputWithPlainFeatures, requestOptions?: RequestOptions): Promise<TermResponse>;
     /**
      * Get a term by ID, live or as it stood at an instant.
      *
@@ -38339,40 +39677,140 @@ declare class TermsClient {
      */
     termExists(termId: string, requestOptions?: RequestOptions): Promise<boolean>;
     /**
-     * Bulk-create terms.
+     * Create many terms in one request, all-or-nothing by default.
      *
-     * @param request - Bulk creation request.
-     * @returns Bulk creation result with term UUIDs.
+     * @param request - The rows, plus `dryRun` to check without writing and
+     *   `partial` to keep the rows that passed. Features may be plain JS values
+     *   or `Value.*` output.
+     * @param requestOptions - Per-call request options.
+     * @returns What was written (or, on a dry run, what WOULD be written):
+     *   `termsAdded`, `termIds` on a real write, `errors` beside them under
+     *   `partial`, `coreferencedTermIds` on a dry run.
+     * @throws {@link BulkRefusedError} 422 when the batch was refused and
+     *   NOTHING was written. Read `error.rows` — one entry per refused row, each
+     *   naming its `index` in `request.terms`. This is the answer for a refused
+     *   default batch, for a refused dry run, and for a `partial` batch in which
+     *   every row was refused.
+     * @throws {@link ApiError} 409 when the end-of-batch constraint propagation
+     *   refuses the batch as a whole. That verdict cannot be attributed to a row,
+     *   so `partial` does not split it.
+     *
+     * @remarks
+     * **Serialization format: Tagged (`ValueDto`).** Plain feature values are
+     * converted exactly as {@link TermsClient.createTerm} converts them.
+     *
+     * There are three outcomes, and they are distinguishable without reading a
+     * status code:
+     *
+     * 1. **A clean write** — `201`. `termIds` holds one id per request row, in
+     *    request order; `termsAdded` equals its length; `errors` is absent.
+     *    Measured 2026-09-18, a 2-row clean batch:
+     *    `{"terms_added":2,"term_ids":["3d936f37-…","f4a77a0b-…"],
+     *    "processing_time_ms":38,"dry_run":false}`.
+     * 2. **A partial write** — `201`, and only with `partial: true`. Some rows
+     *    landed. `termIds` holds one id per ACCEPTED row, so it is SHORTER than
+     *    `request.terms`, and `errors` sits beside it naming the refused ones.
+     *    Map a refusal back with `errors[].index`, never with a position in
+     *    `termIds`. Measured, a 2-row batch whose second row violates a declared
+     *    range:
+     *    `{"terms_added":1,"term_ids":["d6ba85e6-…"],"errors":[{"index":1,
+     *    "feature":"price","message":"Constraint violation: Feature 'price'
+     *    value violates its declared range/constraint"}],"refused":1,
+     *    "processing_time_ms":37,"dry_run":false}`.
+     * 3. **A refusal** — `422`, thrown as {@link BulkRefusedError}. Nothing was
+     *    written. Measured, the same bad batch WITHOUT `partial`:
+     *    `{"code":"bulk_refused","message":"1 of 2 entries were refused; the
+     *    whole batch was refused and nothing was written","errors":[{"index":1,
+     *    "feature":"price","message":"Constraint violation: …"}]}`. With
+     *    `partial: true` and BOTH rows bad, the same `422`:
+     *    `"2 of 2 entries were refused; the whole batch was refused and nothing
+     *    was written"`.
+     *
+     * **`dryRun` runs every check and writes nothing**, and it answers in the
+     * same two shapes. A clean dry run is `200` and reports NO `termIds` —
+     * measured:
+     * `{"terms_added":2,"coreferenced_term_ids":[],"processing_time_ms":0,
+     * "dry_run":true}`. The absence is deliberate: the rollback discarded every
+     * id it minted, a later real write mints different ones, so the vector would
+     * name nothing. The ids that DO outlive a dry run are the existing entities
+     * a `@key` coreference would have merged into, and they come back as
+     * `coreferencedTermIds`. A dry run over a BAD batch throws
+     * {@link BulkRefusedError} with the same per-row refusals a real write throws
+     * — measured, identical body to outcome 3 — so a caller can validate an
+     * import with one call and never touch the store.
+     *
+     * @example
+     * ```typescript
+     * // Validate an import without writing.
+     * try {
+     *   const check = await client.terms.bulkCreateTerms({ terms: rows, dryRun: true });
+     *   console.log(`${check.termsAdded} rows would be written`); // no check.termIds
+     * } catch (e) {
+     *   if (e instanceof BulkRefusedError) {
+     *     for (const row of e.rows) console.error(`row ${row.index}: ${row.message}`);
+     *   }
+     * }
+     *
+     * // Write what passes, and report what did not.
+     * const result = await client.terms.bulkCreateTerms({ terms: rows, partial: true });
+     * console.log(`${result.termsAdded} written`, result.termIds);
+     * for (const bad of result.errors ?? []) {
+     *   console.warn(`row ${bad.index} (${bad.feature}): ${bad.message}`);
+     * }
+     * ```
      */
-    bulkCreateTerms(request: {
-        terms: Array<Omit<CreateTermRequest, 'features'> & {
-            features: Record<string, PlainFeatureValue>;
-        }>;
-    }, requestOptions?: RequestOptions): Promise<BulkAddTermsResponse>;
+    bulkCreateTerms(request: BulkCreateTermsRequest, requestOptions?: RequestOptions): Promise<BulkAddTermsResponse>;
     /**
-     * List terms for the authenticated tenant.
+     * List one page of the tenant's terms, and say how many there are.
      *
-     * @param query - Optional paging and sort filter. Omit for every term.
-     * @returns The list of terms with total count.
-     * @throws {ApiError} If the request fails.
+     * @param query - Paging, the sort filter, and `includeDerived`. Omit for
+     *   every term.
+     * @param requestOptions - Per-call request options.
+     * @returns The page in `terms`, its length in `count`, the size of the whole
+     *   answer in `total`, and an engine remark in `note`.
+     * @throws {@link ApiError} If the request fails.
      *
      * @remarks
-     * Terms are enriched with sort names, display names, and referenced term summaries.
-     * Requires X-Tenant-Id header (set via client configuration).
-     * Uses the tagged {@link ValueDto} serialization format.
-     *
-     * `sortName` filters on the sort's committed name. For a plugin-contributed
-     * sort that is the namespaced form (`plugin:<plugin-name>:<local>`), which
-     * {@link SortDto.name} carries and {@link SortDto.pluginLocalName} maps back
-     * to the name its author wrote.
+     * **Serialization format: Tagged (`ValueDto`).** Terms are enriched with sort
+     * names, display names, and referenced-term summaries. Requires the
+     * `X-Tenant-Id` header, which the client configuration sets.
+     *
+     * **Page off `total`, not `count`.** `count` is this page's length and
+     * nothing else. Measured 2026-09-18 on a tenant holding 3 terms:
+     * `GET /api/v1/terms?limit=1&offset=2` answered
+     * `{"terms":[…one…],"count":1,"total":3}`. `total` is counted before the
+     * window, so it is the number to compare an offset against.
+     *
+     * **When the page is empty, read `note` before you report "no results".**
+     * The route neither chains nor persists conclusions, so for a sort whose
+     * members exist only by derivation the honest answer in a freshly started
+     * process is zero rows — and `total: 0` reads like an authoritative "no
+     * members", which is false. Measured 2026-09-18, a tenant with `widget`,
+     * subsort `premium_widget`, one `widget` fact and the rule
+     * `widget(name: ?N) → premium_widget(name: ?N)`:
+     * `GET /api/v1/terms?sort_name=premium_widget` answered
+     * `{"terms":[],"count":0,"total":0,"note":"`premium_widget` is a rule
+     * conclusion sort: its members are derived … An empty answer here does not
+     * mean the sort has no members."}`. Without the rule, the same empty answer
+     * carried no note.
+     *
+     * `sortName` filters on the sort's committed name, and on that sort EXACTLY
+     * — a member of a subsort is not answered. For a plugin-contributed sort the
+     * committed name is the namespaced form (`plugin:<plugin-name>:<local>`),
+     * which {@link SortDto.name} carries and {@link SortDto.pluginLocalName}
+     * maps back to the name its author wrote.
      *
      * @example
      * ```typescript
-     * const result = await client.terms.listTerms();
-     * console.log(`Found ${result.count} terms`);
+     * const first = await client.terms.listTerms({ sortName: 'person', limit: 50 });
+     * if (first.terms.length === 0 && first.note) console.info(first.note);
+     * for (let offset = 50; offset < (first.total ?? 0); offset += 50) {
+     *   const page = await client.terms.listTerms({ sortName: 'person', limit: 50, offset });
+     *   // …
+     * }
      *
-     * // Only the first page of one sort's terms.
-     * const page = await client.terms.listTerms({ sortName: 'person', limit: 50 });
+     * // The asserted rows alone — the engine includes conclusions by default.
+     * const asserted = await client.terms.listTerms({ includeDerived: false });
      * ```
      */
     listTerms(query?: ListTermsQuery, requestOptions?: RequestOptions): Promise<TermListResponse>;
@@ -38396,18 +39834,27 @@ declare class TermsClient {
     clearTerms(requestOptions?: RequestOptions): Promise<ClearTermsResponse>;
     /**
      * Create multiple records in a single request.
-     * Alias for {@link bulkCreateTerms}.
+     * Alias for {@link TermsClient.bulkCreateTerms}.
      *
-     * @param request - Bulk creation request.
-     * @returns Bulk creation result with term UUIDs.
+     * @param request - The rows, plus `dryRun` and `partial`.
+     * @param requestOptions - Per-call request options.
+     * @returns What was written, exactly as {@link TermsClient.bulkCreateTerms}
+     *   returns it.
+     * @throws {@link BulkRefusedError} 422 when nothing was written.
+     *
+     * @remarks
+     * **Serialization format: Tagged (`ValueDto`).** Same call, friendlier name
+     * — read {@link TermsClient.bulkCreateTerms} for the three outcomes and for
+     * what a dry run does and does not report.
      *
-     * @see bulkCreateTerms
+     * @example
+     * ```typescript
+     * const result = await client.terms.createMany({ terms: rows, partial: true });
+     * ```
+     *
+     * @see {@link TermsClient.bulkCreateTerms}
      */
-    createMany(request: {
-        terms: Array<Omit<CreateTermRequest, 'features'> & {
-            features: Record<string, PlainFeatureValue>;
-        }>;
-    }, requestOptions?: RequestOptions): Promise<BulkAddTermsResponse>;
+    createMany(request: BulkCreateTermsRequest, requestOptions?: RequestOptions): Promise<BulkAddTermsResponse>;
     /**
      * Walk every matching term, a page at a time.
      *
@@ -38517,7 +39964,7 @@ declare class Inference<SecurityDataType = unknown> {
      */
     bulkRetractTerms: (data: BulkRetractTermsRequest$1, params?: RequestParams) => Promise<HttpResponse<BulkRetractTermsResponse$1, void>>;
     /**
-     * @description This drops the hydrated base facts, the forward-chain `persist_derived` facts and the residuation store, then forgets the hydration flag so the next request reloads the base facts from PostgreSQL. **It does not delete durable data.** The terms are the authority; this is their cache. That makes it the retraction primitive forward chaining otherwise lacks. Chaining is monotonic — delete a `blocks` edge and the derived "A blocks B" survives every later pass, so the KB keeps asserting a relationship the user removed. Clearing and re-chaining rebuilds the closure from the terms that actually exist. # History Until 2026-07-28 this handler enumerated every term in the tenant and deleted it from PostgreSQL, while calling itself "clear facts" and reporting `"Cleared N facts/rules"`. It is reachable with an ordinary tenant credential — unlike `/api/v1/admin/clear-tenant/{tenant_id}`, which gateways block — so a caller reading the name, the path or the response body had no way to know it was a tenant wipe. It destroyed a live tenant that way. Use `DELETE /api/v1/terms/{term_id}` to delete a term, and the admin route to wipe a tenant; deleting durable data must not be something an endpoint does as a side effect of its name. # Authorization Requires X-Tenant-Id header, and the path tenant must match it.
+     * @description This drops the hydrated base facts, the forward-chain `keep_derived` facts and the residuation store, then forgets the hydration flag so the next request reloads the base facts from PostgreSQL. **It does not delete durable data.** The terms are the authority; this is their cache. That makes it the retraction primitive forward chaining otherwise lacks. Chaining is monotonic — delete a `blocks` edge and the derived "A blocks B" survives every later pass, so the KB keeps asserting a relationship the user removed. Clearing and re-chaining rebuilds the closure from the terms that actually exist. # History Until 2026-07-28 this handler enumerated every term in the tenant and deleted it from PostgreSQL, while calling itself "clear facts" and reporting `"Cleared N facts/rules"`. It is reachable with an ordinary tenant credential — unlike `/api/v1/admin/clear-tenant/{tenant_id}`, which gateways block — so a caller reading the name, the path or the response body had no way to know it was a tenant wipe. It destroyed a live tenant that way. Use `DELETE /api/v1/terms/{term_id}` to delete a term, and the admin route to wipe a tenant; deleting durable data must not be something an endpoint does as a side effect of its name. # Authorization Requires X-Tenant-Id header, and the path tenant must match it.
      *
      * @tags inference
      * @name ClearFacts
@@ -38591,7 +40038,7 @@ declare class Inference<SecurityDataType = unknown> {
      * @request POST:/api/v1/inference/forward-chain
      * @secure
      */
-    forwardChain: (data: ForwardChainRequest$1, params?: RequestParams) => Promise<HttpResponse<ForwardChainResponse$1, any>>;
+    forwardChain: (data: ForwardChainRequest$1, params?: RequestParams) => Promise<HttpResponse<ForwardChainResponse$1, TimeoutErrorResponse>>;
     /**
      * @description Runs forward chaining with probabilistic provenance tags. Each derived fact carries a confidence value computed from the provenance semiring operations (noisy-or for disjunction, product for conjunction). This extends the standard forward chain endpoint by tracking how confidence propagates through rule application, enabling probabilistic reasoning over the knowledge base.
      *
@@ -38622,6 +40069,8 @@ declare class Inference<SecurityDataType = unknown> {
      * @secure
      */
     getFacts: (tenantId: string, query?: {
+        /** Include the rule conclusions this process has materialised (default true); send false for the asserted rows alone */
+        include_derived?: boolean;
         /**
          * Max facts to return; omit for all, hard-capped at 10000
          * @min 0
@@ -38923,7 +40372,19 @@ declare class InferenceClient {
      * Forward chaining starts from existing facts and applies rules to derive new facts,
      * repeating until no more new facts can be derived (fixpoint) or limits are reached.
      *
-     * If `persist_derived` is true, derived facts are permanently saved to the database.
+     * `keepDerived: true` keeps the run's derivations RESIDENT so a later `MATCH`
+     * reads them. A default run is rolled back, not merely unwritten — so this
+     * route reports what it derived and leaves the store as it found it. Neither
+     * setting is durable: to repair a tenant whose materialised set has drifted,
+     * use OSFQL `CHAIN;` or {@link AdminClient.rebuildDerivedFacts}.
+     *
+     * `timeoutMs` is a server-side deadline in milliseconds, checked at every
+     * fixpoint boundary and every rule application. Omitted means the engine's own
+     * backstop (`OSFKB_FC_TIMEOUT_SECS`, 300 s by default); `0` opts out entirely.
+     * The route answers `504` when the deadline passes, and the body says whether
+     * a `keepDerived` run kept the partial derivation it had reached.
+     *
+     * @throws {ApiError} With status 504 when the derivation passed its deadline.
      */
     forwardChain(request: Omit<ForwardChainRequest, 'initialFacts'> & {
         initialFacts?: TermInputArg[];
@@ -39151,7 +40612,7 @@ declare class Query<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
     /**
-     * @description Returns all terms with the specified sort OR any of its subtypes. This implements proper OSF polymorphic query semantics where querying a parent sort returns all instances of that sort and its descendants. ## Resolving `sort_name` A name can denote more than one id (see `sort_name_candidates`), and no cheap probe tells which of them the query can actually answer from: on the production adapter `get_sort` and `get_sort_ids_by_names` are bare reads of an in-memory cache with no persistence fallback, while the query's own `get_compatible_sorts` does fall back to Postgres. Confirming a candidate with `get_sort` would therefore 404 every tenant sort created before the last restart — a guard strictly stricter than the thing it guards. So the candidates are **tried** against the real query; only `SortNotFound` moves on to the next, every other failure is returned as-is. A phantom id (minted into the tenant lattice by ingestion and never persisted, #138) cannot be returned: the query authority refuses it and the loop skips past it. When no candidate answers, the sort is not queryable and the honest reply is 404 naming the sort the CALLER asked for — never a 400 leaking an internal `SortId` the caller never supplied. Every candidate that answers **contributes**; the answer is their union, deduplicated by term id. Registration now keeps a tenant to one sort per name (#139), so two answering candidates mean rows a pre-fix engine left behind: one name, two sorts, and the tenant's terms of that type divided between them. Stopping at the first — what this route did — returned one half and reported nothing about the other, because an id the caller never supplied going unqueried raises no error. In the ordinary case exactly one candidate answers and the route runs exactly one term query, as it always did.
+     * @description Returns all terms with the specified sort OR any of its subtypes. This implements proper OSF polymorphic query semantics where querying a parent sort returns all instances of that sort and its descendants. ## Resolving `sort_name` A name can denote more than one id (see `sort_name_candidates`), and no cheap probe tells which of them the query can actually answer from: on the production adapter `get_sort` and `get_sort_ids_by_names` are bare reads of an in-memory cache with no persistence fallback, while the query's own `get_compatible_sorts` does fall back to Postgres. Confirming a candidate with `get_sort` would therefore 404 every tenant sort created before the last restart — a guard strictly stricter than the thing it guards. So the candidates are **tried** against the real query; only `SortNotFound` moves on to the next, every other failure is returned as-is. A phantom id (minted into the tenant lattice by ingestion and never persisted, #138) cannot be returned: the query authority refuses it and the loop skips past it. When no candidate answers, the sort is not queryable and the honest reply is 404 naming the sort the CALLER asked for — never a 400 leaking an internal `SortId` the caller never supplied. Every candidate that answers **contributes**; the answer is their union, deduplicated by term id. Registration now keeps a tenant to one sort per name (#139), so two answering candidates mean rows a pre-fix engine left behind: one name, two sorts, and the tenant's terms of that type divided between them. Stopping at the first — what this route did — returned one half and reported nothing about the other, because an id the caller never supplied going unqueried raises no error. In the ordinary case exactly one candidate answers and the route runs exactly one term query, as it always did. ## Conclusions, and what this route promises The answer is the tenant's durable extension of the browse closure UNIONED with the conclusions this process currently HOLDS — the same set OSFQL `MATCH` reads. That is what makes a rule sort readable here at all: no OSFQL path persists a conclusion, so the durable half is empty for a sort whose members exist only by derivation (#261). This route does NOT chain. It reports what the last chain left, so: * after a restart the derived half is empty until something chains again — `CHAIN`, `PROVE`, a retraction's re-chain, or `POST /api/v1/inference/forward-chain`; * a conclusion whose premise was withdrawn through a door that runs no truth maintenance is still answered until the next chain (`docs/OPEN_DEFECTS.md` #82). `total` is the size of the answer before `offset`/`limit`, counted — never a search bound. Rows are ordered by term id, so a page is stable. When the answer is EMPTY and the browsed sort is a rule conclusion sort, `note` says so and names the routes that materialise the conclusions. A bare `total: 0` reads as an authoritative count, and for a rule sort in a freshly-started process it is the one answer a caller must not take at face value — the same confusion #261 was filed about, one state later.
      *
      * @tags query
      * @name FindBySort
@@ -39261,11 +40722,91 @@ declare class QueryClient {
         pattern: PlainTermPattern;
     }, requestOptions?: RequestOptions): Promise<TermDto[]>;
     /**
-     * Find terms by sort ID, sort name, or with optional filter.
+     * Browse a sort and everything below it, one page at a time.
      *
-     * @param request - Query by sort request. Accepts sort_id (UUID),
-     *   sort_name (human-readable), and optional filter for feature-based filtering.
-     * @returns Array of matching terms (tagged ValueDto format).
+     * @param request - `sortId` (UUID) or `sortName`, an optional feature
+     *   `filter`, the `limit`/`offset` window, and `includeDerived`.
+     * @param requestOptions - Per-call request options.
+     * @returns The page in `terms`, its length in `count`, the size of the whole
+     *   answer in `total`, and an engine remark in `note`.
+     * @throws {@link ApiError} 404 when no sort of that name is queryable for
+     *   the tenant.
+     *
+     * @remarks
+     * **Serialization format: Tagged (`ValueDto`).** This is the polymorphic
+     * browse: a query on a sort answers that sort AND every subsort of it, which
+     * is what distinguishes it from {@link TermsClient.listTerms}'s exact
+     * `sortName` filter.
+     *
+     * **Page off `total`.** `count` is this page's length. `total` is the number
+     * of rows matched BEFORE `offset` and `limit`, counted rather than estimated.
+     *
+     * **A page is stable.** The answer is ordered by term id before the window
+     * is applied, so page 2 neither repeats nor skips a row of page 1. Measured
+     * 2026-09-18 against a 2-member sort:
+     * `POST /api/v1/query/by-sort {"sort_name":"widget","include_derived":true}`
+     * answered ids `829ef5dc-…` then `d4f7a4f8-…` with
+     * `{"count":2,"total":2}`; the same request plus `{"limit":1,"offset":1}`
+     * answered `d4f7a4f8-…` alone with `{"count":1,"total":2}` — the second row,
+     * and the same total.
+     *
+     * **The route does not chain.** It answers the tenant's durable extension
+     * UNIONED with the conclusions this process currently HOLDS. After a restart
+     * the derived half is empty until something chains again. So when the page
+     * is empty, read `note` rather than trusting `total: 0`: measured
+     * 2026-09-18, a tenant with `widget`, subsort `premium_widget`, one `widget`
+     * fact and the rule `widget(name: ?N) → premium_widget(name: ?N)`,
+     * `{"sort_name":"premium_widget"}` answered
+     * `{"terms":[],"count":0,"total":0,"note":"`premium_widget` is a rule
+     * conclusion sort: its members are derived … Materialise them with OSFQL
+     * CHAIN, POST /api/v1/inference/forward-chain, or POST
+     * /api/v1/admin/derived-facts/rebuild/{tenant_id} … An empty answer here
+     * does not mean the sort has no members."}`. Before the rule existed, the
+     * same empty query carried no note.
+     *
+     * @example
+     * ```typescript
+     * const page = await client.query.findBySortPage({
+     *   sortName: 'sales_order',
+     *   includeDerived: true,
+     *   limit: 25,
+     *   offset: 0,
+     * });
+     * if (page.terms.length === 0 && page.note) console.info(page.note);
+     * console.log(`${page.count} of ${page.total}`);
+     * ```
+     *
+     * @see {@link QueryClient.findBySort} — the deprecated array-returning form.
+     */
+    findBySortPage(request: FindBySortRequest, requestOptions?: RequestOptions): Promise<TermListResponse>;
+    /**
+     * Browse a sort and everything below it, discarding the envelope.
+     *
+     * @deprecated Use {@link QueryClient.findBySortPage}, which returns the
+     *   engine's envelope. This method drops `count`, `total` and `note`, so a
+     *   caller cannot tell a full answer from a truncated one, cannot page, and
+     *   reads an empty array for a rule-conclusion sort with no way to see the
+     *   engine's explanation. It is kept so 1.27 callers keep compiling.
+     *
+     * @param request - `sortId` or `sortName`, an optional feature `filter`, the
+     *   `limit`/`offset` window, and `includeDerived`.
+     * @param requestOptions - Per-call request options.
+     * @returns The page's terms alone.
+     * @throws {@link ApiError} 404 when no sort of that name is queryable for
+     *   the tenant.
+     *
+     * @remarks
+     * **Serialization format: Tagged (`ValueDto`).** Identical request,
+     * identical rows, identical ordering — see
+     * {@link QueryClient.findBySortPage} for the measured ordering and paging
+     * contract. The only difference is what is thrown away.
+     *
+     * @example
+     * ```typescript
+     * const terms = await client.query.findBySort({ sortName: 'sales_order' });
+     * ```
+     *
+     * @see {@link QueryClient.findBySortPage}
      */
     findBySort(request: FindBySortRequest, requestOptions?: RequestOptions): Promise<TermDto[]>;
     /**
@@ -49597,6 +51138,51 @@ declare class ConstraintViolationError extends ApiError {
     readonly constraint: string | undefined;
     constructor(message: string, body: unknown, headers: Headers, errorCode?: string, termId?: string, feature?: string, constraint?: string);
 }
+/**
+ * A bulk write the engine refused row by row (HTTP 422).
+ *
+ * @remarks
+ * `POST /api/v1/terms/bulk` used to answer one message about a feature and
+ * write nothing, so a client importing four thousand rows learned that
+ * something, somewhere, was wrong. It now names every refused row by its index
+ * in the request, and this error carries that list.
+ *
+ * Reached three ways, all of them this class:
+ * - an ordinary batch where any row was refused (nothing was written);
+ * - a `partial: true` batch where EVERY row was refused (again nothing was
+ *   written — a partial batch that landed something answers `201` instead, with
+ *   the refusals on {@link BulkAddTermsResponse.errors});
+ * - a `dryRun: true` batch that would have been refused.
+ *
+ * Two failures are NOT this error, because neither can be attributed to a row:
+ * the end-of-batch constraint propagation answers a
+ * {@link ConstraintViolationError} for the whole batch, and a persistence
+ * failure reverts what the batch inserted.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.terms.bulkCreateTerms({ terms });
+ * } catch (e) {
+ *   if (e instanceof BulkRefusedError) {
+ *     for (const row of e.rows) {
+ *       console.error(`row ${row.index}: ${row.message}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class BulkRefusedError extends ApiError {
+    name: string;
+    /**
+     * The refused rows, each naming its index in the request's `terms` array.
+     *
+     * @remarks
+     * Never empty — the engine answers this shape only when it refused something.
+     */
+    readonly rows: readonly BulkRowRefusal[];
+    constructor(message: string, body: unknown, headers: Headers, rows: readonly BulkRowRefusal[], errorCode?: string);
+}
 /**
  * Rate limit error (HTTP 429).
  *
@@ -62316,7 +63902,7 @@ declare class Admin<SecurityDataType = unknown> {
      */
     listTenants: (params?: RequestParams) => Promise<HttpResponse<ListTenantsResponse$1, void>>;
     /**
-     * @description Truncates the derived_facts table for the given tenant and queues a BootstrapAll event covering every analyzed rule. Asynchronous: returns the queue depth and current materialization LSN, not the final state. Concurrent rebuilds for the same tenant are rejected with 409 (per-tenant mutex). Full operational runbook (prerequisites, timings, monitoring, failure recovery, known limitations) lives in .claude/SUB_MS_FORWARD_CHAINING_STATUS.md, section 'Operator runbook — derived-facts rebuild'.
+     * @description Re-materialises the tenant's conclusions SYNCHRONOUSLY: chains the resident store once, so every conclusion the rules prove and the store lacks comes back. `rematerialised` reports how many, and every read surface answers from that store — this is the one call that repairs a drifted tenant (#270). ONE DIRECTION: it does not remove a conclusion the rules no longer support, because the write doors' truth maintenance already does that on the write that changed the premise. It ALSO truncates the durable derived_facts table and queues a BootstrapAll event over every analyzed rule; that half is asynchronous, and `removed` / `rules_queued` / `materialization_lsn` describe it. Concurrent rebuilds for the same tenant are rejected with 409 (per-tenant mutex). Full operational runbook (prerequisites, timings, monitoring, failure recovery, known limitations) lives in .claude/SUB_MS_FORWARD_CHAINING_STATUS.md, section 'Operator runbook — derived-facts rebuild'.
      *
      * @tags admin
      * @name RebuildDerivedFacts
@@ -64950,6 +66536,375 @@ declare class Osfql<SecurityDataType = unknown> {
         /** Filter by category: read | write | control | meta */
         category?: string;
     }, params?: RequestParams) => Promise<HttpResponse<CatalogEntryDoc[], any>>;
+    /**
+     * @description Takes the same body as `POST /api/v1/osfql` (the `query` matters; `atomic` decides whether the answer reports the atomic refusal) and answers: - `mutates` — whether ANY statement writes, folding every nested statement, so an `IF` whose THEN or ELSE branch writes reports `true`, and including an inline-write `MATCH` a first-statement classification would read as safe; - `atomic_refusal` — why the program cannot run as one atomic unit, with the same code the run would refuse with (`drop_sort_in_atomic_program`); - `statements` — one entry per statement with the ENGINE's classification (catalog id, risk tier, and a per-statement `mutates` — not a client-side tokenizer), the exact source text, the sorts named, nested entries for IF branches and `WITH` continuations, and — for each destructive statement — the affected-row count and up to 10 sample rows. The per-statement `mutates` is what a write gate reads: `CHAIN` and `RELEASE RESIDUATIONS` report `true` although they classify as `process_control`, while `MARK`, `CUT` and `SPACE` report `false`. No client has to keep its own table of which process-control statements write; `GET /api/v1/osfql/catalog` carries the same verdict per entry as `never` / `always` / `depends` (#266). The classification comes from the engine's own parse; the counts come from a read-only `MATCH` derived from the destructive statement's pattern and run against a CLONE of the tenant. Nothing runs against the live store, so nothing observable happens in the tenant afterwards. # Examples ```json { "query": "MATCH person(name: ?N); RETRACT person(name: \"Bob\");" } ``` ```json { "query": "DROP SORT person; INSERT person(name: \"Bob\");" } ```
+     *
+     * @tags osfql
+     * @name PreviewOsfql
+     * @summary Preview an OSFQL program: what each statement would do, decided without running anything (#257).
+     * @request POST:/api/v1/osfql/preview
+     * @secure
+     */
+    previewOsfql: (data: OsfqlRequest$1, params?: RequestParams) => Promise<HttpResponse<OsfqlPreviewResponse$1, OsfqlErrorResponse>>;
+}
+
+/**
+ * Types for the UI resource (sort-driven UI descriptors).
+ *
+ * @module
+ */
+
+/** Layout mode for the UI surface. Re-exported from generated types (no camelCase diff). */
+type LayoutModeDto = LayoutModeDto$1;
+/**
+ * One accumulated UI customization from a multi-turn conversation.
+ *
+ * Re-exported from the generated types: the wire shape is already snake_case
+ * throughout (`customization_type`, `props_override`), so there is no camelCase
+ * counterpart to hand-write. Typed as `unknown[]` until the backend described
+ * this surface, which is why nothing checked what a caller put here.
+ */
+type UICustomizationDto$1 = UICustomizationDto$2;
+/**
+ * Safety tier the server assigns to an OSFQL statement carried by a UI action.
+ *
+ * @remarks
+ * Wire values are `snake_case` (`"targeted_destructive"`, `"additive_write"`, …) —
+ * re-exported from the generated types since there is no camelCase diff.
+ *
+ * The tier on a descriptor action is a coarse pre-filter: the server re-derives the
+ * real tier per authored statement at execution time. Destructive tiers
+ * (`targeted_destructive`, `bulk_destructive`) are refused unless the
+ * {@link UIActionRequest.confirm} flag is set.
+ *
+ * @example
+ * ```typescript
+ * const tier: RiskTier = 'targeted_destructive';
+ * ```
+ */
+type RiskTier = RiskTier$1;
+/** Layout slot definition. */
+interface LayoutSlotDto {
+    id: string;
+    label: string;
+}
+/** Layout surface configuration. */
+interface LayoutSurfaceDto {
+    id: string;
+    layoutMode: LayoutModeDto;
+    slots: LayoutSlotDto[];
+}
+/** Validation type (discriminated union). Re-exported from generated types. */
+type ValidationTypeDto = {
+    type: 'required';
+} | {
+    type: 'min';
+    params: number;
+} | {
+    type: 'max';
+    params: number;
+} | {
+    type: 'pattern';
+    params: string;
+} | {
+    type: 'one_of';
+    params: string[];
+} | {
+    type: 'value_type';
+    params: string;
+} | {
+    type: 'date_after';
+    params: string;
+} | {
+    type: 'date_before';
+    params: string;
+};
+/** Validation rule for a UI component. */
+interface ValidationRuleDto {
+    field: string;
+    message: string;
+    ruleType: ValidationTypeDto;
+}
+/**
+ * UI action discriminated union.
+ *
+ * @remarks
+ * Every variant carries a {@link RiskTier} (`riskTier`) and an optional catalog
+ * `statementId` — the server derives both from the action kind and echoes them on
+ * the descriptor. `run_osfql` is the catalog-authored variant: its `statementId` is
+ * required because it names the catalog statement whose OSFQL template the action runs.
+ */
+type UIActionDto = {
+    type: 'submit_form';
+    sortName: string;
+    osfqlTemplate: string;
+    fieldTypes: Record<string, string>;
+    riskTier: RiskTier;
+    statementId?: string | null;
+} | {
+    type: 'load_data';
+    osfqlQuery: string;
+    riskTier: RiskTier;
+    statementId?: string | null;
+} | {
+    type: 'update_form';
+    sortName: string;
+    osfqlTemplate: string;
+    fieldTypes: Record<string, string>;
+    riskTier: RiskTier;
+    statementId?: string | null;
+} | {
+    type: 'delete_record';
+    sortName: string;
+    /** OSFQL template with `{field}` placeholders — present for feature-based deletes. */
+    osfqlTemplate?: string | null;
+    riskTier: RiskTier;
+    statementId?: string | null;
+} | {
+    type: 'trigger_inference';
+    osfqlDerive: string;
+    riskTier: RiskTier;
+    statementId?: string | null;
+} | {
+    type: 'navigate';
+    sortId: string;
+    viewMode: string;
+    termId?: string | null;
+    riskTier: RiskTier;
+    statementId?: string | null;
+} | {
+    type: 'refresh';
+    riskTier: RiskTier;
+    statementId?: string | null;
+} | {
+    type: 'run_osfql';
+    /** Catalog statement id whose OSFQL template this action runs. */
+    statementId: string;
+    /** Human-readable label for the catalog statement. */
+    title: string;
+    osfqlTemplate: string;
+    fieldTypes: Record<string, string>;
+    riskTier: RiskTier;
+};
+/** UI descriptor tree node (recursive). */
+interface UIDescriptorDto {
+    actions?: UIActionDto[];
+    bindingPath?: string;
+    children?: UIDescriptorDto[];
+    initialValues?: object;
+    priority: number;
+    props: object;
+    slotId?: string;
+    sort: string;
+    validationRules?: ValidationRuleDto[];
+}
+/** Assembly statistics for a UI describe response. */
+interface UIAssemblyStatsDto {
+    componentCount: number;
+    dataRows?: number;
+    includedFeatures: number;
+    osfqlExecuted?: string | null;
+    sortName: string;
+    totalFeatures: number;
+    viewMode: string;
+}
+/** Request to describe a UI for a sort. */
+interface UIDescribeRequest {
+    customizations?: UICustomizationDto$1[] | null;
+    loadData?: boolean;
+    maxComponents?: number;
+    maxDepth?: number;
+    priorityThreshold?: number;
+    query?: string | null;
+    sessionId?: string | null;
+    sortId: string;
+    termId?: string | null;
+    /** View mode: `"form"`, `"table"`, `"detail"`, `"card"`, `"tree"`. */
+    viewMode?: string;
+}
+/** Response from a UI describe request. */
+interface UIDescribeResponse {
+    data?: object;
+    descriptor: UIDescriptorDto;
+    layout: LayoutSurfaceDto;
+    stats: UIAssemblyStatsDto;
+}
+/** Request to execute a UI action. */
+interface UIActionRequest {
+    /** Action type: `"submit_form"`, `"update_form"`, `"delete_record"`, `"trigger_inference"`, `"run_osfql"`. */
+    actionType: string;
+    /**
+     * Explicit go-ahead for destructive tiers. The server is the boundary: a destructive
+     * statement without `confirm: true` is refused and nothing is mutated.
+     */
+    confirm?: boolean;
+    /**
+     * Preview only: classify and (for destructive tiers) return the affected-row preview
+     * WITHOUT mutating. Defaults to `false`.
+     */
+    dryRun?: boolean;
+    fieldTypes?: object | null;
+    originalValues?: object | null;
+    /** Raw OSFQL override — gated server-side, rejected with 400 unless explicitly enabled. */
+    osfql?: string | null;
+    /**
+     * OSFQL template with `{field}` placeholders the server substitutes from `values`.
+     * Used by `run_osfql` and by feature-based `delete_record`.
+     */
+    osfqlTemplate?: string | null;
+    sortName?: string | null;
+    /** Catalog statement id echoed from the descriptor action — audit/trace only. */
+    statementId?: string | null;
+    termId?: string | null;
+    values?: object | null;
+}
+/** Preview of the rows a destructive statement would affect (dry-run only). */
+interface AffectedPreviewDto {
+    /** Total number of rows the statement would match. */
+    count: number;
+    /** Up to 10 sample rows. */
+    sampleRows?: object[];
+    /** The destructive statement that WOULD run. */
+    statement: string;
+}
+/** Response from executing a UI action. */
+interface UIActionResponse {
+    /** Present on dry-run of a destructive statement: the rows it would hit. */
+    affectedPreview?: AffectedPreviewDto | null;
+    /** Read-back rows for `run_osfql` reads (goals, global gets, hierarchy, aggregates). */
+    bindings?: unknown[] | null;
+    diagnostics?: string[];
+    /** Echo: `true` means this was a dry-run preview and nothing was mutated. */
+    dryRun?: boolean;
+    error?: string | null;
+    /** Pending review id to surface/approve when {@link UIActionResponse.requiresApproval} is `true`. */
+    pendingReviewId?: string | null;
+    producedTermIds?: string[];
+    /**
+     * `true` means the action was enqueued for human approval and nothing was mutated.
+     * Pairs with {@link UIActionResponse.pendingReviewId}.
+     */
+    requiresApproval?: boolean;
+    /**
+     * `true` means a destructive tier was refused for lack of `confirm: true`
+     * (no mutation happened) — the caller should surface a confirmation flow.
+     */
+    requiresConfirmation?: boolean;
+    /** Server-classified risk tier of the final statement. */
+    riskTier?: RiskTier | null;
+    success: boolean;
+}
+/**
+ * Request to generate a certified UI specification from a natural-language prompt.
+ *
+ * @remarks
+ * The pipeline is certify-or-abstain: an LLM proposes a component tree over the
+ * {@link UiSort} vocabulary, the exact engine screens every component sort, data
+ * binding, load query and action against the tenant's live schema, and either
+ * certifies the spec, repairs it once, or abstains with suggestions. Rows always
+ * come from OSFQL execution after certification — never from the model.
+ *
+ * The tenant is taken from the authenticated principal (never a body field).
+ */
+interface UIGenerateRequest {
+    /**
+     * Allow write actions targeting sorts absent from the live schema
+     * (default: `false` — a generated UI writing to nonexistent schema is a hallucination).
+     */
+    allowNewSorts?: boolean;
+    /**
+     * Iterate on an existing page: its latest version is embedded in the prompt as
+     * "the current interface" and {@link UIGenerateRequest.prompt} becomes the change
+     * instruction. The result saves as the page's next version.
+     */
+    basePage?: string | null;
+    /**
+     * Existing conversation to append this exchange to. Omit to start a new conversation.
+     */
+    conversationId?: string | null;
+    /**
+     * Frontend metadata: whether the generated app renders its write controls as live
+     * (interactive) vs preview-only. Passed through untouched; the backend does not branch on it.
+     */
+    interactive?: boolean | null;
+    /** Whether to execute the spec's load query and inline real rows (default: `true`). */
+    loadData?: boolean;
+    /** Maximum number of components (default: 120). */
+    maxComponents?: number;
+    /** Maximum nesting depth (default: 8). */
+    maxDepth?: number;
+    /**
+     * Which generation pipeline to run: `"classic"` (default — single-call
+     * certify-or-abstain) or `"catalog"` (the intent pipeline). Catalog mode only applies
+     * to a fresh screen: iteration on a {@link UIGenerateRequest.basePage} always runs classic.
+     */
+    pipeline?: string | null;
+    /** What the user wants ("a dashboard of drugs with name and dosage…"). */
+    prompt: string;
+    /** Save the certified spec as a named, versioned page. */
+    saveAsPage?: string | null;
+    /** Dev/debug: request the per-stage catalog-pipeline trace. */
+    trace?: boolean | null;
+}
+/**
+ * Certified prompt-to-UI generation response.
+ *
+ * @remarks
+ * `verdict` is `"certified"`, `"repaired"`, or `"abstained"`. On abstention the
+ * descriptor and layout are absent and `suggestions` carries live-schema alternatives.
+ */
+interface UIGenerateResponse {
+    /** Content-addressed certificate id for the accepted spec. */
+    certificateId?: string;
+    /** Engine-loaded data payload — always produced by OSFQL execution, never by the model. */
+    data?: object;
+    /** The certified component tree. Absent when the verdict is `"abstained"`. */
+    descriptor?: UIDescriptorDto;
+    /** Screening diagnostics (what was ungrounded, what the repair changed). */
+    diagnostics?: unknown[];
+    /** The certified layout surface. Absent when the verdict is `"abstained"`. */
+    layout?: LayoutSurfaceDto;
+    /** Saved page version, when {@link UIGenerateRequest.saveAsPage} was requested. */
+    pageVersion?: number;
+    /** Live-schema suggestions returned when the proposal is refused. */
+    suggestions?: unknown[];
+    /** `certified` | `repaired` | `abstained`. */
+    verdict: string;
+}
+/** Complete hierarchy of UI component sorts. */
+type UiSort = UiSort$1;
+/** A single UI component in the catalog. */
+interface UICatalogEntry {
+    category: string;
+    sort: UiSort;
+}
+/** Response for the UI catalog endpoint. */
+interface UICatalogResponse {
+    components: UICatalogEntry[];
+    count: number;
+}
+
+type ui_AffectedPreviewDto = AffectedPreviewDto;
+type ui_LayoutModeDto = LayoutModeDto;
+type ui_LayoutSlotDto = LayoutSlotDto;
+type ui_LayoutSurfaceDto = LayoutSurfaceDto;
+type ui_RiskTier = RiskTier;
+type ui_UIActionDto = UIActionDto;
+type ui_UIActionRequest = UIActionRequest;
+type ui_UIActionResponse = UIActionResponse;
+type ui_UIAssemblyStatsDto = UIAssemblyStatsDto;
+type ui_UICatalogEntry = UICatalogEntry;
+type ui_UICatalogResponse = UICatalogResponse;
+type ui_UIDescribeRequest = UIDescribeRequest;
+type ui_UIDescribeResponse = UIDescribeResponse;
+type ui_UIDescriptorDto = UIDescriptorDto;
+type ui_UIGenerateRequest = UIGenerateRequest;
+type ui_UIGenerateResponse = UIGenerateResponse;
+type ui_UiSort = UiSort;
+type ui_ValidationRuleDto = ValidationRuleDto;
+type ui_ValidationTypeDto = ValidationTypeDto;
+declare namespace ui {
+  export type { ui_AffectedPreviewDto as AffectedPreviewDto, ui_LayoutModeDto as LayoutModeDto, ui_LayoutSlotDto as LayoutSlotDto, ui_LayoutSurfaceDto as LayoutSurfaceDto, ui_RiskTier as RiskTier, ui_UIActionDto as UIActionDto, ui_UIActionRequest as UIActionRequest, ui_UIActionResponse as UIActionResponse, ui_UIAssemblyStatsDto as UIAssemblyStatsDto, ui_UICatalogEntry as UICatalogEntry, ui_UICatalogResponse as UICatalogResponse, UICustomizationDto$1 as UICustomizationDto, ui_UIDescribeRequest as UIDescribeRequest, ui_UIDescribeResponse as UIDescribeResponse, ui_UIDescriptorDto as UIDescriptorDto, ui_UIGenerateRequest as UIGenerateRequest, ui_UIGenerateResponse as UIGenerateResponse, ui_UiSort as UiSort, ui_ValidationRuleDto as ValidationRuleDto, ui_ValidationTypeDto as ValidationTypeDto };
 }
 
 /**
@@ -65105,6 +67060,20 @@ type OsfqlValue = {
 } | {
     type: 'boolean';
     value: boolean;
+}
+/**
+ * A UTC instant in its RFC 3339 `Z`-suffixed form — the binding of a
+ * `date`/`timestamp` feature, or of a `MIN`/`MAX` aggregate over one.
+ *
+ * @remarks
+ * The engine publishes this variant in `OsfqlValueDto`, so a `datetime`
+ * binding, `FETCH` feature or preview sample-row column can carry it. It is
+ * a `string` rather than a `Date` because the value is the engine's own
+ * rendering and the SDK never reformats a response.
+ */
+ | {
+    type: 'datetime';
+    value: string;
 } | {
     type: 'list';
     value: OsfqlValue[];
@@ -65270,6 +67239,20 @@ interface OsfqlCatalogEntry {
     examples: string[];
     /** Safety tier, snake_case (e.g. `read`, `additive_write`). */
     risk: string;
+    /**
+     * Whether this statement writes the store: `never`, `always`, or `depends`
+     * when only the authored arguments can decide.
+     *
+     * @remarks
+     * {@link category} cannot answer this. `CHAIN` and `RELEASE RESIDUATIONS` are
+     * `Control` and both write; `MATCH` is `Read` and writes whenever it carries
+     * an inline clause. Read this field instead of keeping a table of which
+     * process-control statements write.
+     *
+     * `depends` is resolved by {@link OsfqlClient.preview}, whose per-statement
+     * `mutates` is a concrete boolean. Copied verbatim, like {@link risk}.
+     */
+    mutates: string;
     /** How far the engine executes this statement. */
     execution: OsfqlCatalogExecution;
     /** UI role — display and/or action. */
@@ -65285,20 +67268,269 @@ interface OsfqlCatalogEntry {
     /** Known gotchas and engine caveats for this statement. */
     pitfalls: string[];
 }
+/**
+ * One sort's share of an affected-row set.
+ *
+ * @remarks
+ * Produced only for a statement whose reach is the whole tenant — `CLEAR FACTS`
+ * — where ten sample rows say almost nothing and the shape of what is about to
+ * go is the useful answer.
+ *
+ * @example
+ * ```typescript
+ * const share: OsfqlPreviewSortCount = { sort: 'customer', count: 3 };
+ * ```
+ */
+interface OsfqlPreviewSortCount {
+    /** The sort's name, or its id when the tenant's lattice cannot name it. */
+    sort: string;
+    /** How many of the affected rows are of this sort. */
+    count: number;
+}
+/**
+ * The rows a destructive statement would affect.
+ *
+ * @remarks
+ * The engine counts them by deriving a read-only `MATCH` from the destructive
+ * statement's own pattern and running it against a CLONE of the tenant. Nothing
+ * runs against the live store.
+ *
+ * {@link exact} says whether {@link count} is the number of rows that would go,
+ * or an upper bound. Measured 2026-09-19: for
+ * `MATCH customer(name: ?N, spend: ?S); IF ?S > 60 THEN RETRACT customer(name: ?N);`
+ * over three customers of which one has `spend > 60`, the nested `RETRACT`
+ * answers `{count: 3, exact: false}` — the one-statement probe cannot carry the
+ * `IF` condition, because `?S` is bound by an earlier statement and folding the
+ * guard in would raise an unbound-variable error and lose the count entirely.
+ * So the engine states the superset and marks it. `RETRACT customer(spend: 100)`
+ * at the top level answers `{count: 1, exact: true}`.
+ *
+ * Read `exact` rather than guessing from nesting: a nested statement whose
+ * enclosing conditions name only its own variables is exact too.
+ *
+ * @example
+ * ```typescript
+ * const affected: OsfqlPreviewAffected = {
+ *   count: 2,
+ *   sampleRows: [{ term_id: { type: 'term_ref', value: '…' }, tier: { type: 'string', value: 'gold' } }],
+ * };
+ * ```
+ */
+interface OsfqlPreviewAffected {
+    /**
+     * How many rows the statement would affect.
+     *
+     * @remarks
+     * `0` means zero rows, and it is answered whenever the rows were counted —
+     * measured, both `RETRACT customer(name: "nobody")` against a populated sort
+     * and `RETRACT event(at: ?T)` against an empty one answer
+     * `{count: 0, exact: true}`. It is the absence of the whole
+     * {@link OsfqlPreviewStatement.affected} block that means the statement has
+     * no affected-row set at all.
+     *
+     * Exact unless {@link exact} says otherwise.
+     */
+    count: number;
+    /**
+     * Whether {@link count} is exact, or an upper bound.
+     *
+     * @remarks
+     * `false` for a statement nested under a condition the engine's
+     * one-statement probe cannot carry, where the probe selects a SUPERSET of
+     * what would go — render it as "up to N rows". `true` for every top-level
+     * statement, and for a nested statement whose enclosing conditions name only
+     * its own variables.
+     *
+     * Absent from an older engine, where every count was effectively an upper
+     * bound for a nested statement and exact otherwise.
+     */
+    exact?: boolean;
+    /**
+     * Up to 10 sample rows, one map per matched row.
+     *
+     * @remarks
+     * Each row IDENTIFIES the row it stands for: a `term_id` column, the features
+     * the statement's own pattern projected, and the declaring sort's `@key`
+     * features. The keys are DATA — OSF feature names — so they are left
+     * verbatim, never camelCased.
+     *
+     * Absent for a whole-tenant statement, which answers with {@link bySort}
+     * instead.
+     */
+    sampleRows?: Record<string, OsfqlValue>[];
+    /**
+     * How the affected rows fall across sorts, most rows first.
+     *
+     * @remarks
+     * Present for a whole-tenant statement (`CLEAR FACTS`). Absent for a targeted
+     * `RETRACT`, whose sort is already in {@link OsfqlPreviewStatement.sorts}.
+     */
+    bySort?: OsfqlPreviewSortCount[];
+}
+/**
+ * Why a previewed program cannot run as one atomic unit, answered without
+ * running it.
+ *
+ * @remarks
+ * The same verdict `POST /api/v1/osfql` would refuse the program with. Reported
+ * only when the previewed request is atomic (the engine's default).
+ *
+ * @example
+ * ```typescript
+ * const refusal: OsfqlAtomicRefusal = {
+ *   code: 'drop_sort_in_atomic_program',
+ *   message: 'DROP SORT cannot take part in an atomic program: …',
+ * };
+ * ```
+ */
+interface OsfqlAtomicRefusal {
+    /** Machine-readable cause, e.g. `drop_sort_in_atomic_program`. */
+    code: string;
+    /** Human-readable explanation, identical to the run-time refusal. */
+    message: string;
+}
+/**
+ * One statement of a previewed OSFQL program.
+ *
+ * @remarks
+ * The shape is **recursive**: {@link nested} carries the branches of an `IF`
+ * and the continuations of a `WITH`. {@link index} is a single counter over the
+ * whole program, not a position among siblings — an `IF` at index 1 whose two
+ * branches are previewed carries nested entries at index 2 and 3.
+ *
+ * Read {@link mutates}, not {@link risk}, to decide whether a statement writes.
+ * The two disagree by design, and both directions were measured:
+ * `MATCH customer(name: ?N) INSERT vip(name: ?N)` is `risk: "read"` with
+ * `mutates: true`; `MARK ?m1`, `CUT` and `SPACE CREATE ?S` are
+ * `risk: "process_control"` with `mutates: false`, while `CHAIN` and
+ * `RELEASE RESIDUATIONS` share that same tier and report `mutates: true`.
+ *
+ * @example
+ * ```typescript
+ * const statement: OsfqlPreviewStatement = {
+ *   index: 0,
+ *   id: 'retract',
+ *   statement: 'Retract',
+ *   risk: 'targeted_destructive',
+ *   mutates: true,
+ *   sorts: ['customer'],
+ *   source: 'RETRACT customer(tier: "gold")',
+ *   affected: { count: 2 },
+ * };
+ * ```
+ */
+interface OsfqlPreviewStatement {
+    /** Position in a single counter over the whole program, nested entries included. */
+    index: number;
+    /** Catalog id of the statement, e.g. `match`, `retract`, `clear_facts`. */
+    id: string;
+    /** Exact AST variant name, e.g. `Match`, `Retract`, `Clear`. */
+    statement: string;
+    /**
+     * Safety tier the engine assigned this entry — a coarse pre-filter.
+     *
+     * @remarks
+     * This is the real {@link RiskTier} union, because the preview route's own
+     * schema publishes the enum. {@link OsfqlCatalogEntry.risk} beside it is a
+     * plain `string` on purpose: the catalog's documented contract is that its
+     * enum values are copied verbatim out of a DEBUG/introspection endpoint whose
+     * fields mix casing, so narrowing it would make the SDK reject a value the
+     * engine is free to add there. Do not "fix" either one to match the other.
+     *
+     * An entry with mixed sub-operations carries its most-dangerous dominant
+     * tier, and the security boundary re-derives the real tier per authored
+     * statement at execution — so this is a hint for the UI, never the gate.
+     */
+    risk: RiskTier;
+    /** Whether THIS statement writes the store. The verdict a write gate reads. */
+    mutates: boolean;
+    /** The sort names the statement names. Empty for a statement that names none. */
+    sorts: string[];
+    /** The exact source text of the statement, without its terminating `;`. */
+    source: string;
+    /**
+     * The rows the statement would affect.
+     *
+     * @remarks
+     * Absent means the statement HAS no affected-row set — a read, or an additive
+     * write, which adds rows rather than reaching existing ones. Measured
+     * 2026-09-19: a `MATCH` and an `INSERT` carry no `affected` block, while a
+     * destructive statement always carries one, `count: 0` included. So absence
+     * is a statement about the KIND of statement, and the count is a statement
+     * about the rows.
+     *
+     * This was ambiguous until the engine separated the two cases: a zero-row
+     * `RETRACT` used to omit the block, so a confirm dialog could not tell "we
+     * did not look" from "nothing will go". It can now.
+     */
+    affected?: OsfqlPreviewAffected;
+    /**
+     * The statements nested inside this one — the `THEN` and `ELSE` branches of
+     * an `IF`, the continuations of a `WITH`. Absent when there are none.
+     */
+    nested?: OsfqlPreviewStatement[];
+}
+/**
+ * Response from previewing an OSFQL program: what each statement would do,
+ * decided without running anything.
+ *
+ * @remarks
+ * Always HTTP 200 for a program that parses, including the empty program, which
+ * answers `{ mutates: false, statements: [] }`. A program that does not parse is
+ * HTTP 400 with an `OsfqlErrorResponse` body, surfaced as an `ApiError`.
+ *
+ * @example
+ * ```typescript
+ * const preview = await client.osfql.preview('RETRACT customer(tier: "gold");');
+ * if (preview.mutates) {
+ *   const destructive = preview.statements.filter((s) => s.mutates);
+ *   console.log(destructive[0].affected?.count); // 2
+ * }
+ * ```
+ */
+interface OsfqlPreviewResponse {
+    /**
+     * Whether ANY statement of the program mutates the store.
+     *
+     * @remarks
+     * It folds every nested statement. Verified against the dev engine on
+     * 2026-09-18: `MATCH customer(name: ?N, spend: ?S); IF ?S > 60 THEN RETRACT
+     * customer(name: ?N);` answers `true`, and so does an `IF` whose only writing
+     * branch is the `ELSE`. It also folds an inline-write `MATCH`, which a
+     * first-statement classification would read as safe.
+     */
+    mutates: boolean;
+    /** One entry per top-level statement, in document order. */
+    statements: OsfqlPreviewStatement[];
+    /**
+     * Why the program cannot run as one atomic unit, when it cannot and the
+     * previewed request is atomic (the default).
+     *
+     * @remarks
+     * Absent — or `null` — otherwise. Previewing the same program with
+     * `atomic: false` drops the field, because the refusal no longer applies.
+     */
+    atomicRefusal?: OsfqlAtomicRefusal | null;
+}
 
+type osfql_OsfqlAtomicRefusal = OsfqlAtomicRefusal;
 type osfql_OsfqlCatalogEntry = OsfqlCatalogEntry;
 type osfql_OsfqlCatalogExecution = OsfqlCatalogExecution;
 type osfql_OsfqlCatalogUiAffinity = OsfqlCatalogUiAffinity;
 type osfql_OsfqlDiagnoseRequest = OsfqlDiagnoseRequest;
 type osfql_OsfqlDiagnoseResponse = OsfqlDiagnoseResponse;
 type osfql_OsfqlDiagnostic = OsfqlDiagnostic;
+type osfql_OsfqlPreviewAffected = OsfqlPreviewAffected;
+type osfql_OsfqlPreviewResponse = OsfqlPreviewResponse;
+type osfql_OsfqlPreviewSortCount = OsfqlPreviewSortCount;
+type osfql_OsfqlPreviewStatement = OsfqlPreviewStatement;
 type osfql_OsfqlRange = OsfqlRange;
 type osfql_OsfqlRequest = OsfqlRequest;
 type osfql_OsfqlResponse = OsfqlResponse;
 type osfql_OsfqlTermValue = OsfqlTermValue;
 type osfql_OsfqlValue = OsfqlValue;
 declare namespace osfql {
-  export type { osfql_OsfqlCatalogEntry as OsfqlCatalogEntry, osfql_OsfqlCatalogExecution as OsfqlCatalogExecution, osfql_OsfqlCatalogUiAffinity as OsfqlCatalogUiAffinity, osfql_OsfqlDiagnoseRequest as OsfqlDiagnoseRequest, osfql_OsfqlDiagnoseResponse as OsfqlDiagnoseResponse, osfql_OsfqlDiagnostic as OsfqlDiagnostic, osfql_OsfqlRange as OsfqlRange, osfql_OsfqlRequest as OsfqlRequest, osfql_OsfqlResponse as OsfqlResponse, osfql_OsfqlTermValue as OsfqlTermValue, osfql_OsfqlValue as OsfqlValue };
+  export type { osfql_OsfqlAtomicRefusal as OsfqlAtomicRefusal, osfql_OsfqlCatalogEntry as OsfqlCatalogEntry, osfql_OsfqlCatalogExecution as OsfqlCatalogExecution, osfql_OsfqlCatalogUiAffinity as OsfqlCatalogUiAffinity, osfql_OsfqlDiagnoseRequest as OsfqlDiagnoseRequest, osfql_OsfqlDiagnoseResponse as OsfqlDiagnoseResponse, osfql_OsfqlDiagnostic as OsfqlDiagnostic, osfql_OsfqlPreviewAffected as OsfqlPreviewAffected, osfql_OsfqlPreviewResponse as OsfqlPreviewResponse, osfql_OsfqlPreviewSortCount as OsfqlPreviewSortCount, osfql_OsfqlPreviewStatement as OsfqlPreviewStatement, osfql_OsfqlRange as OsfqlRange, osfql_OsfqlRequest as OsfqlRequest, osfql_OsfqlResponse as OsfqlResponse, osfql_OsfqlTermValue as OsfqlTermValue, osfql_OsfqlValue as OsfqlValue };
 }
 
 /**
@@ -65308,7 +67540,9 @@ declare namespace osfql {
  * Provides access to the OSFQL execution endpoint, which parses, compiles,
  * and executes OSFQL programs against the tenant-isolated knowledge base;
  * an ephemeral {@link OsfqlClient.diagnose} pass that reports contradictions without
- * writing anything; and the {@link OsfqlClient.catalog} statement introspection endpoint.
+ * writing anything; a {@link OsfqlClient.preview} pass that says what each statement
+ * WOULD do, including the rows a destructive one would touch; and the
+ * {@link OsfqlClient.catalog} statement introspection endpoint.
  *
  * Supported statement types include MATCH, INSERT, RETRACT, DERIVE, UNIFY,
  * DEFINE, AWAIT, COUNTERFACTUAL, and CAUSES.
@@ -65375,6 +67609,95 @@ declare class OsfqlClient {
      * ```
      */
     execute(query: string, options?: Omit<OsfqlRequest, 'query'>, requestOptions?: RequestOptions): Promise<OsfqlResponse>;
+    /**
+     * Preview an OSFQL program: what each statement would do, decided without
+     * running anything.
+     *
+     * @param query - The OSFQL program text (one or more statements separated by `;`).
+     * @param options - Optional request options. Only `atomic` changes the answer:
+     *   it decides whether `atomicRefusal` is reported. `reactive`, `maxRows` and
+     *   `timeoutMs` are accepted for wire parity with {@link execute} and are
+     *   ignored by the route.
+     * @param requestOptions - Per-call transport options (timeout, signal, headers).
+     * @returns The per-statement classification, the affected-row reports, and the
+     *   atomic refusal when there is one.
+     * @throws {ApiError} If the program does not parse (HTTP 400, `OsfqlErrorResponse`),
+     *   or the request otherwise fails.
+     * @throws {ReasoningLayerError} If a sample row carries a value that does not satisfy
+     *   the published {@link OsfqlValue} contract.
+     *
+     * @remarks
+     * **Why call this instead of classifying the program client-side.** Three
+     * answers only the engine's own parse can give:
+     *
+     * 1. **Per-statement `mutates`.** A client keeps no table of which
+     *    process-control statements write. Measured on the dev engine: `CHAIN` and
+     *    `RELEASE RESIDUATIONS` report `mutates: true`, while `MARK ?m1`, `CUT` and
+     *    `SPACE CREATE ?S` report `false` — all five are `risk: "process_control"`.
+     *    In the other direction, `MATCH customer(name: ?N) INSERT vip(name: ?N)`
+     *    is `risk: "read"` with `mutates: true`. Read `mutates`, never `risk`.
+     * 2. **`affected.count` and `affected.sampleRows`.** Up to 10 rows, each
+     *    identifying itself with a `term_id` column and the declaring sort's
+     *    `@key` features, so a confirm dialog can say WHICH rows go, not just how
+     *    many. Counted by running a derived read-only `MATCH` against a clone of
+     *    the tenant. Verified: four destructive previews (`RETRACT`, `CLEAR FACTS`,
+     *    `DROP SORT`, `DEFINE`) left the tenant's fact count and its lattice
+     *    unchanged.
+     * 3. **`atomicRefusal`.** The same `drop_sort_in_atomic_program` verdict
+     *    `POST /api/v1/osfql` would refuse the program with, answered before the
+     *    program runs.
+     *
+     * ⚠️ **The one thing a caller must NOT do: treat `affected.count` as the
+     * number of rows the run will remove.** It is the reach of the statement's
+     * PATTERN. For `MATCH customer(name: ?N, spend: ?S); IF ?S > 60 THEN RETRACT
+     * customer(name: ?N);` over three customers of which one has `spend > 60`, the
+     * nested `RETRACT` answers `count: 3` — the derived `MATCH customer(name: ?N)`
+     * applies neither the `IF` condition nor the binding the earlier statement
+     * gives `?N`. Present it as "up to N rows" for a nested statement or one that
+     * reads a variable from an earlier statement.
+     *
+     * Two further measured facts. The top-level `mutates` DOES fold nested
+     * statements now: the `IF` program above answers `true`, and so does an `IF`
+     * whose only writing branch is the `ELSE` — the earlier defect where an `IF`
+     * with a writing branch answered `false` is fixed. And `affected` being absent
+     * is ambiguous: `RETRACT customer(tier: "bronze")` matching zero rows omits
+     * the field entirely rather than answering `count: 0`, exactly as a read does.
+     *
+     * `statement.index` is a single counter over the whole program: an `IF` at
+     * index 1 carries nested entries at index 2 and 3.
+     *
+     * Request serialization matches {@link execute} — `query` plus the optional
+     * `atomic` / `reactive` / `max_rows` / `timeout_ms` keys. The program TEXT is
+     * a string value, so the request bridge's snake_case pass does not touch it;
+     * a `camelCase` feature name inside the query survives verbatim. Sample-row
+     * KEYS are data and are not camelCased on the way back.
+     *
+     * @example
+     * ```typescript
+     * const preview = await client.osfql.preview(
+     *   'MATCH customer(name: ?N); RETRACT customer(tier: "gold");'
+     * );
+     *
+     * console.log(preview.mutates);                  // true
+     * const writes = preview.statements.filter((s) => s.mutates);
+     * console.log(writes[0].id);                     // "retract"
+     * console.log(writes[0].risk);                   // "targeted_destructive"
+     * console.log(writes[0].affected?.count);        // 2
+     * console.log(writes[0].affected?.sampleRows);   // [{ term_id: …, tier: … }, …]
+     *
+     * // A DROP SORT cannot share an atomic program
+     * const refused = await client.osfql.preview('DROP SORT widget; INSERT widget(label: "x");');
+     * console.log(refused.atomicRefusal?.code);      // "drop_sort_in_atomic_program"
+     *
+     * // Ask the same question without the atomic constraint
+     * const loose = await client.osfql.preview(
+     *   'DROP SORT widget; INSERT widget(label: "x");',
+     *   { atomic: false },
+     * );
+     * console.log(loose.atomicRefusal);              // undefined
+     * ```
+     */
+    preview(query: string, options?: Omit<OsfqlRequest, 'query'>, requestOptions?: RequestOptions): Promise<OsfqlPreviewResponse>;
     /**
      * Diagnose an OSFQL program for contradictions and inconsistencies.
      *
@@ -65736,7 +68059,7 @@ interface ReasoningTraceDto {
 /**
  * UI customization detected from a conversation response.
  */
-interface UICustomizationDto$1 {
+interface UICustomizationDto {
     /** Type of customization. */
     customizationType: string;
     /** JSONPath-style target for modifications. */
@@ -65789,7 +68112,7 @@ interface ConversationMessageResponse {
     /** Proof tree for this response (populated when PROVE / backward chaining was used). */
     proofTrace?: ProofTraceNodeDto | null;
     /** UI customizations detected in this response (for multi-turn UI evolution). */
-    uiCustomizations?: UICustomizationDto$1[] | null;
+    uiCustomizations?: UICustomizationDto[] | null;
     /**
      * Cognitive strategy used for this response (when RL training is active and a
      * cognitive agent exists for the tenant). Absent on plain conversation turns.
@@ -65993,8 +68316,9 @@ type conversation_ResolvedCoreferenceDto = ResolvedCoreferenceDto;
 type conversation_SchemaExcerptDto = SchemaExcerptDto;
 type conversation_SessionGraphDto = SessionGraphDto;
 type conversation_TurnDto = TurnDto;
+type conversation_UICustomizationDto = UICustomizationDto;
 declare namespace conversation {
-  export type { conversation_CitationCheckDto as CitationCheckDto, conversation_ClaimAnnotationDto as ClaimAnnotationDto, conversation_CognitiveStrategyDto as CognitiveStrategyDto, conversation_CompareModelDto as CompareModelDto, conversation_ConversationMessageRequest as ConversationMessageRequest, conversation_ConversationMessageResponse as ConversationMessageResponse, conversation_ConversationSummaryDto as ConversationSummaryDto, conversation_ConversationTurnsResponse as ConversationTurnsResponse, conversation_DerivationSummaryDto as DerivationSummaryDto, conversation_FocusEntryDto as FocusEntryDto, conversation_ListConversationsResponse as ListConversationsResponse, conversation_MatchedEntityDto as MatchedEntityDto, conversation_ProofTraceNodeDto as ProofTraceNodeDto, conversation_ReasoningStageDto as ReasoningStageDto, conversation_ReasoningTraceDto as ReasoningTraceDto, conversation_RecordTurnRequest as RecordTurnRequest, conversation_RecordTurnResponse as RecordTurnResponse, conversation_ResolvedCoreferenceDto as ResolvedCoreferenceDto, conversation_SchemaExcerptDto as SchemaExcerptDto, conversation_SessionGraphDto as SessionGraphDto, SourceExcerptDto$1 as SourceExcerptDto, conversation_TurnDto as TurnDto, UICustomizationDto$1 as UICustomizationDto };
+  export type { conversation_CitationCheckDto as CitationCheckDto, conversation_ClaimAnnotationDto as ClaimAnnotationDto, conversation_CognitiveStrategyDto as CognitiveStrategyDto, conversation_CompareModelDto as CompareModelDto, conversation_ConversationMessageRequest as ConversationMessageRequest, conversation_ConversationMessageResponse as ConversationMessageResponse, conversation_ConversationSummaryDto as ConversationSummaryDto, conversation_ConversationTurnsResponse as ConversationTurnsResponse, conversation_DerivationSummaryDto as DerivationSummaryDto, conversation_FocusEntryDto as FocusEntryDto, conversation_ListConversationsResponse as ListConversationsResponse, conversation_MatchedEntityDto as MatchedEntityDto, conversation_ProofTraceNodeDto as ProofTraceNodeDto, conversation_ReasoningStageDto as ReasoningStageDto, conversation_ReasoningTraceDto as ReasoningTraceDto, conversation_RecordTurnRequest as RecordTurnRequest, conversation_RecordTurnResponse as RecordTurnResponse, conversation_ResolvedCoreferenceDto as ResolvedCoreferenceDto, conversation_SchemaExcerptDto as SchemaExcerptDto, conversation_SessionGraphDto as SessionGraphDto, SourceExcerptDto$1 as SourceExcerptDto, conversation_TurnDto as TurnDto, conversation_UICustomizationDto as UICustomizationDto };
 }
 
 /**
@@ -67778,366 +70102,6 @@ declare class Ui<SecurityDataType = unknown> {
     uiCatalog: (params?: RequestParams) => Promise<HttpResponse<UICatalogResponse$1, any>>;
 }
 
-/**
- * Types for the UI resource (sort-driven UI descriptors).
- *
- * @module
- */
-
-/** Layout mode for the UI surface. Re-exported from generated types (no camelCase diff). */
-type LayoutModeDto = LayoutModeDto$1;
-/**
- * One accumulated UI customization from a multi-turn conversation.
- *
- * Re-exported from the generated types: the wire shape is already snake_case
- * throughout (`customization_type`, `props_override`), so there is no camelCase
- * counterpart to hand-write. Typed as `unknown[]` until the backend described
- * this surface, which is why nothing checked what a caller put here.
- */
-type UICustomizationDto = UICustomizationDto$2;
-/**
- * Safety tier the server assigns to an OSFQL statement carried by a UI action.
- *
- * @remarks
- * Wire values are `snake_case` (`"targeted_destructive"`, `"additive_write"`, …) —
- * re-exported from the generated types since there is no camelCase diff.
- *
- * The tier on a descriptor action is a coarse pre-filter: the server re-derives the
- * real tier per authored statement at execution time. Destructive tiers
- * (`targeted_destructive`, `bulk_destructive`) are refused unless the
- * {@link UIActionRequest.confirm} flag is set.
- *
- * @example
- * ```typescript
- * const tier: RiskTier = 'targeted_destructive';
- * ```
- */
-type RiskTier = RiskTier$1;
-/** Layout slot definition. */
-interface LayoutSlotDto {
-    id: string;
-    label: string;
-}
-/** Layout surface configuration. */
-interface LayoutSurfaceDto {
-    id: string;
-    layoutMode: LayoutModeDto;
-    slots: LayoutSlotDto[];
-}
-/** Validation type (discriminated union). Re-exported from generated types. */
-type ValidationTypeDto = {
-    type: 'required';
-} | {
-    type: 'min';
-    params: number;
-} | {
-    type: 'max';
-    params: number;
-} | {
-    type: 'pattern';
-    params: string;
-} | {
-    type: 'one_of';
-    params: string[];
-} | {
-    type: 'value_type';
-    params: string;
-} | {
-    type: 'date_after';
-    params: string;
-} | {
-    type: 'date_before';
-    params: string;
-};
-/** Validation rule for a UI component. */
-interface ValidationRuleDto {
-    field: string;
-    message: string;
-    ruleType: ValidationTypeDto;
-}
-/**
- * UI action discriminated union.
- *
- * @remarks
- * Every variant carries a {@link RiskTier} (`riskTier`) and an optional catalog
- * `statementId` — the server derives both from the action kind and echoes them on
- * the descriptor. `run_osfql` is the catalog-authored variant: its `statementId` is
- * required because it names the catalog statement whose OSFQL template the action runs.
- */
-type UIActionDto = {
-    type: 'submit_form';
-    sortName: string;
-    osfqlTemplate: string;
-    fieldTypes: Record<string, string>;
-    riskTier: RiskTier;
-    statementId?: string | null;
-} | {
-    type: 'load_data';
-    osfqlQuery: string;
-    riskTier: RiskTier;
-    statementId?: string | null;
-} | {
-    type: 'update_form';
-    sortName: string;
-    osfqlTemplate: string;
-    fieldTypes: Record<string, string>;
-    riskTier: RiskTier;
-    statementId?: string | null;
-} | {
-    type: 'delete_record';
-    sortName: string;
-    /** OSFQL template with `{field}` placeholders — present for feature-based deletes. */
-    osfqlTemplate?: string | null;
-    riskTier: RiskTier;
-    statementId?: string | null;
-} | {
-    type: 'trigger_inference';
-    osfqlDerive: string;
-    riskTier: RiskTier;
-    statementId?: string | null;
-} | {
-    type: 'navigate';
-    sortId: string;
-    viewMode: string;
-    termId?: string | null;
-    riskTier: RiskTier;
-    statementId?: string | null;
-} | {
-    type: 'refresh';
-    riskTier: RiskTier;
-    statementId?: string | null;
-} | {
-    type: 'run_osfql';
-    /** Catalog statement id whose OSFQL template this action runs. */
-    statementId: string;
-    /** Human-readable label for the catalog statement. */
-    title: string;
-    osfqlTemplate: string;
-    fieldTypes: Record<string, string>;
-    riskTier: RiskTier;
-};
-/** UI descriptor tree node (recursive). */
-interface UIDescriptorDto {
-    actions?: UIActionDto[];
-    bindingPath?: string;
-    children?: UIDescriptorDto[];
-    initialValues?: object;
-    priority: number;
-    props: object;
-    slotId?: string;
-    sort: string;
-    validationRules?: ValidationRuleDto[];
-}
-/** Assembly statistics for a UI describe response. */
-interface UIAssemblyStatsDto {
-    componentCount: number;
-    dataRows?: number;
-    includedFeatures: number;
-    osfqlExecuted?: string | null;
-    sortName: string;
-    totalFeatures: number;
-    viewMode: string;
-}
-/** Request to describe a UI for a sort. */
-interface UIDescribeRequest {
-    customizations?: UICustomizationDto[] | null;
-    loadData?: boolean;
-    maxComponents?: number;
-    maxDepth?: number;
-    priorityThreshold?: number;
-    query?: string | null;
-    sessionId?: string | null;
-    sortId: string;
-    termId?: string | null;
-    /** View mode: `"form"`, `"table"`, `"detail"`, `"card"`, `"tree"`. */
-    viewMode?: string;
-}
-/** Response from a UI describe request. */
-interface UIDescribeResponse {
-    data?: object;
-    descriptor: UIDescriptorDto;
-    layout: LayoutSurfaceDto;
-    stats: UIAssemblyStatsDto;
-}
-/** Request to execute a UI action. */
-interface UIActionRequest {
-    /** Action type: `"submit_form"`, `"update_form"`, `"delete_record"`, `"trigger_inference"`, `"run_osfql"`. */
-    actionType: string;
-    /**
-     * Explicit go-ahead for destructive tiers. The server is the boundary: a destructive
-     * statement without `confirm: true` is refused and nothing is mutated.
-     */
-    confirm?: boolean;
-    /**
-     * Preview only: classify and (for destructive tiers) return the affected-row preview
-     * WITHOUT mutating. Defaults to `false`.
-     */
-    dryRun?: boolean;
-    fieldTypes?: object | null;
-    originalValues?: object | null;
-    /** Raw OSFQL override — gated server-side, rejected with 400 unless explicitly enabled. */
-    osfql?: string | null;
-    /**
-     * OSFQL template with `{field}` placeholders the server substitutes from `values`.
-     * Used by `run_osfql` and by feature-based `delete_record`.
-     */
-    osfqlTemplate?: string | null;
-    sortName?: string | null;
-    /** Catalog statement id echoed from the descriptor action — audit/trace only. */
-    statementId?: string | null;
-    termId?: string | null;
-    values?: object | null;
-}
-/** Preview of the rows a destructive statement would affect (dry-run only). */
-interface AffectedPreviewDto {
-    /** Total number of rows the statement would match. */
-    count: number;
-    /** Up to 10 sample rows. */
-    sampleRows?: object[];
-    /** The destructive statement that WOULD run. */
-    statement: string;
-}
-/** Response from executing a UI action. */
-interface UIActionResponse {
-    /** Present on dry-run of a destructive statement: the rows it would hit. */
-    affectedPreview?: AffectedPreviewDto | null;
-    /** Read-back rows for `run_osfql` reads (goals, global gets, hierarchy, aggregates). */
-    bindings?: unknown[] | null;
-    diagnostics?: string[];
-    /** Echo: `true` means this was a dry-run preview and nothing was mutated. */
-    dryRun?: boolean;
-    error?: string | null;
-    /** Pending review id to surface/approve when {@link UIActionResponse.requiresApproval} is `true`. */
-    pendingReviewId?: string | null;
-    producedTermIds?: string[];
-    /**
-     * `true` means the action was enqueued for human approval and nothing was mutated.
-     * Pairs with {@link UIActionResponse.pendingReviewId}.
-     */
-    requiresApproval?: boolean;
-    /**
-     * `true` means a destructive tier was refused for lack of `confirm: true`
-     * (no mutation happened) — the caller should surface a confirmation flow.
-     */
-    requiresConfirmation?: boolean;
-    /** Server-classified risk tier of the final statement. */
-    riskTier?: RiskTier | null;
-    success: boolean;
-}
-/**
- * Request to generate a certified UI specification from a natural-language prompt.
- *
- * @remarks
- * The pipeline is certify-or-abstain: an LLM proposes a component tree over the
- * {@link UiSort} vocabulary, the exact engine screens every component sort, data
- * binding, load query and action against the tenant's live schema, and either
- * certifies the spec, repairs it once, or abstains with suggestions. Rows always
- * come from OSFQL execution after certification — never from the model.
- *
- * The tenant is taken from the authenticated principal (never a body field).
- */
-interface UIGenerateRequest {
-    /**
-     * Allow write actions targeting sorts absent from the live schema
-     * (default: `false` — a generated UI writing to nonexistent schema is a hallucination).
-     */
-    allowNewSorts?: boolean;
-    /**
-     * Iterate on an existing page: its latest version is embedded in the prompt as
-     * "the current interface" and {@link UIGenerateRequest.prompt} becomes the change
-     * instruction. The result saves as the page's next version.
-     */
-    basePage?: string | null;
-    /**
-     * Existing conversation to append this exchange to. Omit to start a new conversation.
-     */
-    conversationId?: string | null;
-    /**
-     * Frontend metadata: whether the generated app renders its write controls as live
-     * (interactive) vs preview-only. Passed through untouched; the backend does not branch on it.
-     */
-    interactive?: boolean | null;
-    /** Whether to execute the spec's load query and inline real rows (default: `true`). */
-    loadData?: boolean;
-    /** Maximum number of components (default: 120). */
-    maxComponents?: number;
-    /** Maximum nesting depth (default: 8). */
-    maxDepth?: number;
-    /**
-     * Which generation pipeline to run: `"classic"` (default — single-call
-     * certify-or-abstain) or `"catalog"` (the intent pipeline). Catalog mode only applies
-     * to a fresh screen: iteration on a {@link UIGenerateRequest.basePage} always runs classic.
-     */
-    pipeline?: string | null;
-    /** What the user wants ("a dashboard of drugs with name and dosage…"). */
-    prompt: string;
-    /** Save the certified spec as a named, versioned page. */
-    saveAsPage?: string | null;
-    /** Dev/debug: request the per-stage catalog-pipeline trace. */
-    trace?: boolean | null;
-}
-/**
- * Certified prompt-to-UI generation response.
- *
- * @remarks
- * `verdict` is `"certified"`, `"repaired"`, or `"abstained"`. On abstention the
- * descriptor and layout are absent and `suggestions` carries live-schema alternatives.
- */
-interface UIGenerateResponse {
-    /** Content-addressed certificate id for the accepted spec. */
-    certificateId?: string;
-    /** Engine-loaded data payload — always produced by OSFQL execution, never by the model. */
-    data?: object;
-    /** The certified component tree. Absent when the verdict is `"abstained"`. */
-    descriptor?: UIDescriptorDto;
-    /** Screening diagnostics (what was ungrounded, what the repair changed). */
-    diagnostics?: unknown[];
-    /** The certified layout surface. Absent when the verdict is `"abstained"`. */
-    layout?: LayoutSurfaceDto;
-    /** Saved page version, when {@link UIGenerateRequest.saveAsPage} was requested. */
-    pageVersion?: number;
-    /** Live-schema suggestions returned when the proposal is refused. */
-    suggestions?: unknown[];
-    /** `certified` | `repaired` | `abstained`. */
-    verdict: string;
-}
-/** Complete hierarchy of UI component sorts. */
-type UiSort = UiSort$1;
-/** A single UI component in the catalog. */
-interface UICatalogEntry {
-    category: string;
-    sort: UiSort;
-}
-/** Response for the UI catalog endpoint. */
-interface UICatalogResponse {
-    components: UICatalogEntry[];
-    count: number;
-}
-
-type ui_AffectedPreviewDto = AffectedPreviewDto;
-type ui_LayoutModeDto = LayoutModeDto;
-type ui_LayoutSlotDto = LayoutSlotDto;
-type ui_LayoutSurfaceDto = LayoutSurfaceDto;
-type ui_RiskTier = RiskTier;
-type ui_UIActionDto = UIActionDto;
-type ui_UIActionRequest = UIActionRequest;
-type ui_UIActionResponse = UIActionResponse;
-type ui_UIAssemblyStatsDto = UIAssemblyStatsDto;
-type ui_UICatalogEntry = UICatalogEntry;
-type ui_UICatalogResponse = UICatalogResponse;
-type ui_UICustomizationDto = UICustomizationDto;
-type ui_UIDescribeRequest = UIDescribeRequest;
-type ui_UIDescribeResponse = UIDescribeResponse;
-type ui_UIDescriptorDto = UIDescriptorDto;
-type ui_UIGenerateRequest = UIGenerateRequest;
-type ui_UIGenerateResponse = UIGenerateResponse;
-type ui_UiSort = UiSort;
-type ui_ValidationRuleDto = ValidationRuleDto;
-type ui_ValidationTypeDto = ValidationTypeDto;
-declare namespace ui {
-  export type { ui_AffectedPreviewDto as AffectedPreviewDto, ui_LayoutModeDto as LayoutModeDto, ui_LayoutSlotDto as LayoutSlotDto, ui_LayoutSurfaceDto as LayoutSurfaceDto, ui_RiskTier as RiskTier, ui_UIActionDto as UIActionDto, ui_UIActionRequest as UIActionRequest, ui_UIActionResponse as UIActionResponse, ui_UIAssemblyStatsDto as UIAssemblyStatsDto, ui_UICatalogEntry as UICatalogEntry, ui_UICatalogResponse as UICatalogResponse, ui_UICustomizationDto as UICustomizationDto, ui_UIDescribeRequest as UIDescribeRequest, ui_UIDescribeResponse as UIDescribeResponse, ui_UIDescriptorDto as UIDescriptorDto, ui_UIGenerateRequest as UIGenerateRequest, ui_UIGenerateResponse as UIGenerateResponse, ui_UiSort as UiSort, ui_ValidationRuleDto as ValidationRuleDto, ui_ValidationTypeDto as ValidationTypeDto };
-}
-
 /**
  * Resource client for sort-driven UI descriptor operations.
  *
@@ -71839,84 +73803,6 @@ declare class OntologyAlignment<SecurityDataType = unknown> {
     alignOntology: (data: AlignOntologyRequest$1, params?: RequestParams) => Promise<HttpResponse<AlignOntologyResponse$1, void>>;
 }
 
-/**
- * Request to align a domain ontology against one or more upper ontologies.
- *
- * @remarks
- * Sent to `POST /api/v1/ontology/align`. Wire format is snake_case
- * (`domain_owl`).
- */
-interface AlignOntologyRequest {
-    /** Domain ontology to align, as OWL/RDF-XML. */
-    domainOwl: string;
-    /** Upper ontologies to align against. Defaults to `["BFO"]` when empty. */
-    targets?: string[];
-}
-/**
- * A confirmed SKOS correspondence from a domain class to an upper-ontology class.
- */
-interface AlignmentMatchDto {
-    /** Domain sort name. */
-    domainSort: string;
-    /** SKOS relation: `exactMatch` / `broadMatch` / `narrowMatch` / `closeMatch`. */
-    matchType: string;
-    /** Upper-ontology class CURIE (e.g. the BFO IRI's CURIE form). */
-    targetCurie: string;
-    /** Upper-ontology class label. */
-    targetLabel: string;
-}
-/**
- * Two upper-ontology candidates a domain class cannot map to simultaneously
- * (their lattice meet is ⊥ — e.g. disjoint BFO branches).
- */
-interface AlignmentConflictDto {
-    /** Domain sort name whose candidates conflict. */
-    domainSort: string;
-    /** The kept (higher-scored) candidate CURIE. */
-    targetA: string;
-    /** The rejected, incompatible candidate CURIE. */
-    targetB: string;
-}
-/**
- * A SKOS external-ontology alignment attached to a sort.
- *
- * @remarks
- * Populated by the upper-ontology aligner so each correspondence is a live,
- * queryable property of the sort rather than a separate static export.
- */
-interface ExternalMatchDto {
-    /** SKOS mapping relation: `exactMatch` | `closeMatch` | `broadMatch` | `narrowMatch`. */
-    matchType: string;
-    /** CURIE of the aligned external concept (e.g. `obo:BFO_0000023`). */
-    ontologyId: string;
-    /** How the match was discovered: `grounding` | `manual` | `import` | `inferred`. */
-    source: string;
-}
-/**
- * Response from an ontology-alignment run.
- */
-interface AlignOntologyResponse {
-    /** Surfaced ⊥-conflicts among proposed candidates. */
-    conflicts: AlignmentConflictDto[];
-    /** Number of domain sorts considered. */
-    domainSorts: number;
-    /** The MAPPING artifact as Turtle (`skos:*` + `kortexya:confidence`). */
-    mappingTtl: string;
-    /** Confirmed SKOS correspondences. */
-    matches: AlignmentMatchDto[];
-    /** Number of upper-ontology target sorts indexed. */
-    targetSorts: number;
-}
-
-type ontologyAlignment_AlignOntologyRequest = AlignOntologyRequest;
-type ontologyAlignment_AlignOntologyResponse = AlignOntologyResponse;
-type ontologyAlignment_AlignmentConflictDto = AlignmentConflictDto;
-type ontologyAlignment_AlignmentMatchDto = AlignmentMatchDto;
-type ontologyAlignment_ExternalMatchDto = ExternalMatchDto;
-declare namespace ontologyAlignment {
-  export type { ontologyAlignment_AlignOntologyRequest as AlignOntologyRequest, ontologyAlignment_AlignOntologyResponse as AlignOntologyResponse, ontologyAlignment_AlignmentConflictDto as AlignmentConflictDto, ontologyAlignment_AlignmentMatchDto as AlignmentMatchDto, ontologyAlignment_ExternalMatchDto as ExternalMatchDto };
-}
-
 /**
  * Resource client for ontology-alignment operations.
  *
@@ -82772,20 +84658,58 @@ declare class ReasoningLayerClient {
  */
 declare const Value: {
     /**
-     * Create a reference to another term by UUID.
+     * Create a reference to another stored term — by its UUID, or by the `@key`
+     * values that name it.
      *
-     * @param id - The UUID of the referenced term.
-     * @returns A tagged `ReferenceValue`: `{"type": "Reference", "value": "uuid"}`.
+     * @param target - The referenced term's UUID, or a {@link ReferenceDesignator}
+     *   naming it through the `@key` features of its sort.
+     * @returns A tagged `ReferenceValue`: `{"type": "Reference", "value": "uuid"}`
+     *   for the id form, `{"type":"Reference","value":{"sort_name":…,"features":…}}`
+     *   for the designator form.
+     * @throws {@link ValidationError} when the designator carries an empty
+     *   `sortName`, or names no feature — the engine refuses both, so the builder
+     *   refuses them before the round trip.
      *
      * @remarks
-     * Serialization format: Tagged (ValueDto). Use with term CRUD, queries, fuzzy operations.
+     * **Serialization format: Tagged (`ValueDto`).** Use with term CRUD, queries
+     * and fuzzy operations. The homoiconic inference endpoints take the untagged
+     * format and have no designator form.
+     *
+     * The two forms differ in what they can be used for:
+     *
+     * - The **UUID form** is what a read answers, and the only form that can
+     *   point at a term whose sort declares no `@key`.
+     * - The **designator form** is WRITE-side only. It RESOLVES to a term that
+     *   already exists and never mints one: measured on 2026-09-18, writing
+     *   a `payment` whose `invoice` feature was
+     *   `Value.reference({ sortName: 'invoice', features: { number: { type: 'String', value: 'INV-1' } } })`
+     *   stored `{"type":"Reference","value":"4641cbcb-…"}` — the id of the single
+     *   existing invoice — and the invoice extent still held exactly one term. A
+     *   designator matching nothing is refused `422 no term of sort 'invoice'
+     *   carries @key 'number' = "INV-NOPE"; a reference designator names an
+     *   existing term, it never creates one`. The same refusal arrives from
+     *   `POST /api/v1/terms/bulk` as a `BulkRefusedError` naming the entry index.
+     *
+     * The designator's `features` keys are OSF feature names — user data, not
+     * schema — and survive the request bridge verbatim, so a feature declared
+     * `invoiceNumber` must be spelled `invoiceNumber` here. Sending the
+     * snake_cased spelling is refused: `422 feature 'invoice_number' of sort
+     * 'invoice' is not a @key feature; a designator addresses a term only through
+     * its @key`.
      *
      * @example
      * ```typescript
+     * // By id:
      * Value.reference("550e8400-e29b-41d4-a716-446655440000")
+     *
+     * // By @key, when the caller has the business key and not the UUID:
+     * Value.reference({
+     *   sortName: 'invoice',
+     *   features: { number: { type: 'String', value: 'INV-1' } },
+     * })
      * ```
      */
-    readonly reference: (id: string) => ReferenceValue;
+    readonly reference: (target: string | ReferenceDesignator) => ReferenceValue;
     /**
      * Create a reference to a sort by UUID.
      *
@@ -84006,6 +85930,114 @@ declare function psi(sort: {
  * ```
  */
 declare function bind<T extends PsiTermInput>(name: string, term: T): T;
+/**
+ * Negate an antecedent — negation as failure over the tenant's facts.
+ *
+ * @param clause - The pattern that must NOT be provable, from {@link psi}.
+ * @returns The `negation` carrier term to put in a rule's `antecedents`.
+ * @throws {@link ValidationError} when `clause` is itself a negation carrier.
+ *
+ * @remarks
+ * **Serialization format: untagged `TermInputDto`.** A negated antecedent is
+ * not a flag — it is an inline term of the reserved meta-sort `negation` whose
+ * `clause` feature carries the probed pattern:
+ *
+ * ```json
+ * {"sort_name":"negation","features":{"clause":{"sort_name":"payment","features":{"invoice_number":{"name":"?N"}}}}}
+ * ```
+ *
+ * That is the shape `POST /api/v1/inference/rules` accepts, measured on
+ * 2026-09-18. `GET /api/v1/inference/rules/{tenant}` reads it back as a body
+ * entry of `sort_name: "negation"` whose `clause` feature is the nested pattern
+ * term, `display: "NOT EXISTS payment(invoice_number: ?N)"`, and gives the rule
+ * the OSFQL spelling
+ * `DERIVE unpaid(number: ?N) WHEN invoice(number: ?N), NOT EXISTS payment(invoice_number: ?N);`.
+ *
+ * **One pattern per negation.** The chainers read the carrier exactly one
+ * constraint deep. A nested `not(not(x))` IS accepted by the write route and
+ * renders `NOT EXISTS NOT EXISTS …`, but derives nothing — measured, a rule
+ * with a doubly negated antecedent produced zero rows where single negation
+ * produced one — so this builder refuses it rather than let a rule fail
+ * silently.
+ *
+ * The negated clause binds nothing. Every head variable must also appear in a
+ * POSITIVE antecedent, or the rule is refused
+ * `422 rule rejected: head variable(s) ?N not bound by any antecedent`. For the
+ * same reason a {@link bind} binder inside the carrier has no identity to name,
+ * and the nested-term conversion drops it.
+ *
+ * @example
+ * ```typescript
+ * import { not, psi } from '@kortexya/reasoninglayer';
+ *
+ * // "an invoice with no payment against it"
+ * await client.inference.addRule({
+ *   term: psi('unpaid', { number: '?N' }),
+ *   antecedents: [
+ *     psi('invoice', { number: '?N' }),
+ *     not(psi('payment', { invoice_number: '?N' })),
+ *   ],
+ * });
+ * ```
+ */
+declare function not(clause: PsiTermInput): PsiTermInputByName;
+/**
+ * The aggregation operators the engine accepts on a rule head.
+ *
+ * @remarks
+ * Any other word is refused with
+ * `422 rule rejected: the aggregator operator \`median\` is not one of sum, max, min, count, first`
+ * — measured on 2026-09-18.
+ */
+type RuleAggregatorOp = 'sum' | 'max' | 'min' | 'count' | 'first';
+/**
+ * Declare engine-side aggregation on a rule head.
+ *
+ * @param spec - The group key, the operator and the feature to aggregate.
+ * @param spec.groupBy - Feature names that define the aggregation group. Proofs
+ *   agreeing on all of them are merged into one conclusion.
+ * @param spec.op - One of the five operators in {@link RuleAggregatorOp}.
+ * @param spec.target - The feature whose value is aggregated inside each group.
+ * @returns The descriptor to pass as `addRule`'s `aggregator`.
+ * @throws {@link ValidationError} when `groupBy` is empty, when a `groupBy`
+ *   entry or `target` is blank, or when `target` also appears in `groupBy` —
+ *   a feature cannot be both the group key and the aggregated value.
+ *
+ * @remarks
+ * **Serialization format: snake_case wire keys.** The descriptor rides on the
+ * REQUEST, not on the head: `POST /api/v1/inference/rules` takes it as a
+ * top-level `aggregator` and the listing lifts it back onto the rule entry as
+ * `{"group_by":["customer_id"],"op":"sum","target":"amount"}`, never as a
+ * feature of the head. Measured on 2026-09-18 — the returned head's `features`
+ * map holds only `customer_id`, `amount` and `when`.
+ *
+ * An aggregating rule has NO OSFQL spelling: the same listing omits `osfql`
+ * entirely for it, while the negation rule beside it carried one. A UI must
+ * disable "edit as text" for such a rule rather than guess.
+ *
+ * Without the descriptor the rule derives one conclusion PER PROOF; with it,
+ * one per group. Measured: three `order` facts (`cust-a` 10.0, `cust-a` 32.5,
+ * `cust-b` 7.25) under
+ * `DERIVE total_spend(customer_id: ?C, amount: ?A) WHEN order(customer_id: ?C, amount: ?A)`
+ * with `aggregate({ groupBy: ['customer_id'], op: 'sum', target: 'amount' })`
+ * produced exactly two rows — `cust-a` 42.5 and `cust-b` 7.25.
+ *
+ * @example
+ * ```typescript
+ * import { aggregate, psi } from '@kortexya/reasoninglayer';
+ *
+ * await client.inference.addRule({
+ *   term: psi('total_spend', { customer_id: '?C', amount: '?A' }),
+ *   antecedents: [psi('order', { customer_id: '?C', amount: '?A' })],
+ *   aggregator: aggregate({ groupBy: ['customer_id'], op: 'sum', target: 'amount' }),
+ * });
+ * ```
+ */
+declare function aggregate(spec: {
+    groupBy: string[];
+    op: RuleAggregatorOp;
+    target: string;
+}): RuleAggregatorDto;
 /**
  * Create a constrained variable for use in `psi()` features.
  *
@@ -84591,4 +86623,4 @@ declare function toUntaggedFeatures(features: PlainFeatureMap): Record<string, F
  */
 declare function toTermInputDto(input: PsiTermInput | TermInputDto): TermInputDto;
 
-export { ANY_ROLE, type ActValueDto, type ActionParamRule, type ActionParameter, type ActionReviewReasonDto, type ActionReviewReasonFilter, type ActionReviewResponse, type ActionReviewStatusDto, type ActionReviewSummaryDto, actionReviews as ActionReviews, type ActionSideEffect, type ActionType, type ActionTypeDef, type ActionTypeListResponse, actions as Actions, type ActivationDto, type AdaptiveModifyRequest, type AdaptiveModifyResponse, type AddBeliefRequest, type AddBeliefResponse, type AddCausalRelationRequest, type AddCausalRelationResponse, type AddCognitiveRuleRequest, type AddCognitiveRuleResponse, type AddConnectorRequest, type AddConnectorResponse, type AddConstraintsRequest, type AddConstraintsResponse, type AddExportRequest, type AddFactRequest, type AddFactResponse, type AddGoalRequest, type AddGoalResponse, type AddHtnMethodRequest, type AddHtnMethodResponse, type AddImportRequest, type AddPendingReviewRequest, type AddRuleRequest, type AddRuleResponse, type AddSymbolRequest, type AddSymbolResponse, admin as Admin, type AdmissibleDto, type AffectedPreviewDto, type AgentBeliefDto, type AgentConfigDto, type AgentEvent, type AgentEventHandlers, type AgentGoalDto, type AgentRecallAsOfRequest, type AgentRecallAsOfResponse, type AgentSpec, type AgentStateDto, type AgentSubVerdictDto, type AgentSubscription, type AgentTrajectoryRequest, type AgentTrajectoryResponse, agui as Agui, type AguiContextItem, type AguiEvent, type AguiFunctionCall, type AguiMessage, type AguiRole, type AguiRunOptions, type AguiTool, type AguiToolCall, type AiGroup, type AlcConcept, type AlignOntologyRequest, type AlignOntologyResponse, type AlignmentConflictDto, type AlignmentMatchDto, type AllenRelation, analysis as Analysis, type AnalysisGroup, type AnalyzeDocumentsRequest, type AnalyzeOptions, anonymization as Anonymization, type AnonymizationMode, type AnonymizeRequest, type AnonymizeResponse, type AntiUnifyBatchRequest, type AntiUnifyBatchResponse, type AntiUnifyRequest, type AntiUnifyResponse, ApiError, type ApiResponse, type AppendAuditEntryRequest, type AppendRequest, type AppendResiduationsRequest, type AppendResiduationsResponse, type ApplyActionRequest, type ApplyActionResponse, type ApplyCurriedRequest, type ApplyCurriedResponse, type ApplySnapshotResponse, type ApproveActionRequest, type ApproveEntityRequest, type ApproveLearnedSimilarityRequest, type ApproveLearnedSimilarityResponse, type ArchitectureInfoDto, type ArithOpDto, type ArithValueDto, type ArithmeticConstraintDto, type ArithmeticExprDto, type ArithmeticOp, type ArithmeticRecursionOp, type ArtifactDto, type AscRequest, type AssembleContextRequest, type AssembleContextResponse, type AssembledConceptDto, type AssembledRelationDto, type AssemblyTokenCountsDto, type AssertRuleRequest, type AssertRuleResponse, type AssignValueDto, type Assignment, type AssignmentMechanism, type AssignmentRowDto, type AssignmentStatus, type AssumptionAuditRequest, type AssumptionAuditResponse, type AssumptionRequest, type AsyncIngestionResponse, type AteEstimateRequest, type AteEstimateResponse, type AttentionTargetDto, type AttestationDto, audit as Audit, type AuditEntryDto, type AuditPage, type AuditRecord, type AuditSortField, type AuditSortOrder, type AuditedAssumptionDto, type AugmentationTargetDto, type AuthConfig, AuthenticationError, type AuthoringClarificationQuestionDto, authz as Authz, type AuthzAction, type AuthzDryRunRequest, type AuthzDryRunResponse, type AuthzEffect, type BacktrackResponse, type BacktrackTermStoreRequest, type BacktrackTermStoreResponse, type BacktrackableAssignRequest, type BacktrackableAssignResponse, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, batch as Batch, type BatchCopyRequest, type BatchOperationDto, type BatchOperationResultDto, type BatchRequest, type BatchResponse, type BatchStringCompareRequest, type BayesianEffectDto, type BayesianPredictRequest, type BayesianPredictResponse, type BeliefDto, type BellShape, type BigIntegerValue, type BinaryOperatorDto, type BindSortRequest, type BindSortResponse, type BindTermRequest, type BindTermResponse, type BindVariableRequest, type BindVariableResponse, type BindVariablesRequest, type BindVariablesResponse, type BindingDto, type BindingSummaryDto, type BindingsResponse, type BitwiseOperationType, type BitwiseRequest, type BloomFilterStats, type BoolExpr, type BooleanValue, type BoundConstraintDto, type BoundingBoxGeometry, type BroadcastMessageRequest, type BroadcastMessageResponse, type BuildInfoDto, type BulkActionReviewResponse, type BulkAddFactsRequest, type BulkAddFactsResponse, type BulkAddRulesRequest, type BulkAddRulesResponse, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkApproveActionsRequest, type BulkApproveRequest, type BulkBindError, type BulkBindSortsRequest, type BulkBindSortsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, type BulkFuzzyProveRequest, type BulkFuzzyProveResponse, type BulkMergeRequest, type BulkRejectActionsRequest, type BulkRejectRequest, type BulkRetractTermsRequest, type BulkRetractTermsResponse, type BulkSetSimilaritiesRequest, type BulkSetSimilaritiesResponse, type BulkSortDefinition, type BulkSortError, type BulkSortErrorKind, type BySortQueryRequest, cdl as CDL, type CalibrateRequest, type CalibrationReportDto, type CalibrationSample, type CallOnceRequest, type CallOnceResponse, type CandidateMatchDto, type CaptureSnapshotRequest, type CascadeOptions, type CatalogPage, type CategoryProbabilityDto, type CauchyShape, causal as Causal, type CausalActionSpecDto, type CausalAnalyzeAssumptionsDto, type CausalAnalyzeDataDto, type CausalAnalyzeIndependenceTestDto, type CausalAnalyzePolicyDto, type CausalAnalyzeQuestionDto, type CausalAnalyzeQuestionKind, type CausalAnalyzeRegressionDto, type CausalAnalyzeRequest, type CausalAncestorRequest, type CausalAncestorResponse, type CausalAssumptionDto, type CausalChainDto, type CausalDecisionSpecDto, type CausalDerivationStepDto, type CausalEdgeDto, type CausalHedgeDto, type CausalProofTreeDto, type CausalRelationshipDto$1 as CausalRelationshipDto, type CausationProbabilitiesRequest, type CausationProbabilitiesResponse, type CausesRequest, type CausesResponse, type CdlComponentStatus, type CdlStatusResponse, type CdlVerificationDto, type CeilingDto, type CentralityRequest, type CentralityResponse, type CertificateDetail, type CertificateDto, type CertifiedForecast, chase as Chase, type ChaseArgDto, type ChaseAtomDto, type ChaseRunRequest, type ChaseRunResponse, type ChaseStepKindDto, type CheckDiversityRequest, type CheckDiversityResponse, type CheckDocumentRequest, type CheckDocumentResponse, type CheckFinding, type CheckSummary, type ChoicePoint, type ChoicePointDto, type ChoicePointMarkerResponse, type ChoiceSelection, type ChoiceValue, type ChrRequest, type ChunkFailureDto, type CircleGeometry, type CitationCheckDto, type CitationMarkerDto, type ClaimAnnotationDto, type ClaimAssessment, type ClaimCitation, type ClaimSubtype, type ClaimVerdict, type ClarificationQuestionDto, type Classification, type ClassificationLevelDto, type ClassifyEdgesInput, type ClassifyEdgesVars, type ClassifyProblemRequest, type ClassifyProblemResponse, type ClassifySafetyRequest, type ClassifySafetyResponse, type CleanupResponse, type CleanupSessionsResponse, type CleanupStaleSessionsParams, type ClearFactsResponse, type ClearTenantResponse, type ClearTermsResponse, type ClientConfig, type ClusteredAteRequest, type ClusteredObservationDto, cognitive as Cognitive, type CognitiveGoalDto, type CognitiveStrategyDto, type CognitiveTermInput, coherence as Coherence, type CoherenceAnalyzeRequest, type CoherenceAnalyzeResponse, type CoherenceClaimDto, type CoherenceInlineDocumentDto, type CoherenceSummaryDto, type CohesionRequest, type CohesionResponse, type CollectionDto, collections as Collections, type ColumnMappingDto, type CommitFlowNetworkRequest, type CommitRequest, type CommittedForecast, communities as Communities, type CommunityDetectionConfigDto, type CommunityDetectionStatsDto, type CommunityDto, type CommunityMatchDto, type CommunityReportDto, type CommunityReportSummaryDto, type CommunitySearchModeDto, type CommunitySearchStatsDto, type CommunityStatsDto, type CompareDocumentsRequest, type CompareModelDto, type ComparisonOp, type CompetitorForecast, compliance as Compliance, complianceMarkings as ComplianceMarkings, type ComponentDto, type ComponentHealthDto, type ComputeGlbResponse, type ComputeLubResponse, type ConceptMatchDto, type CondRequest, type CondResponse, type ConditionalBranchDto, type ConditionalIndependenceRequest, type ConditionalIndependenceResponse, type ConfirmResponse, type ConflictResolution, type ConfluenceConflictDto, type ConfluenceDto, conformal as Conformal, type ConformalCalibrateRequest, type ConformalCalibrateResponse, type ConformalPredictRequest, type ConformalPredictResponse, type ConformalPrediction, conformance as Conformance, type ConformanceCheckResponse, type ConformanceRepairResponse, type ConformanceRequest, type ConformityArticleDto, type ConformityResponse, type ConnectorInstance, type ConnectorType, connectors as Connectors, type ConstrainedGenerateRequest, type ConstrainedGenerateResponse, type ConstrainedPlainVar, Constraint, type ConstraintCheckDto, type ConstraintDto, type ConstraintGraphRequest, type ConstraintGraphResponse, type ConstraintGraphStats, type ConstraintInputDto, type ConstraintOperator, type ConstraintSense, type ConstraintSessionStatus, ConstraintViolationError, constraints as Constraints, type ContainmentVerificationDto, type ContinuousMediationObservationDto, type ContinuousObservationDto, type ContinuousTreatmentObservationDto, type ContradictionDto, type ContradictionResolutionDto, control as Control, type ControlNafRequest, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTrainingConfigDto, type ConversationTurnDto, type ConversationTurnsResponse, type CoordinatedResourceSet, type CopyModeDto, type CopyTermRequest, type CoreGroup, corpus as Corpus, type CorpusBridgeEdge, type CorpusBridgesRequest, type CorpusBridgesResponse, type CorpusCommunitiesRequest, type CorpusCommunitiesResponse, type CorpusCommunity, type CorpusCommunityDocumentShare, type CorpusCrossCuttingItem, type CorpusCrossCuttingItemKind, type CorpusCrossCuttingKind, type CorpusCrossCuttingRequest, type CorpusCrossCuttingResponse, type CorpusDocumentNode, type CorpusEntityRef, type CorpusScope, type CorpusSharedEntity, type CorpusTreemapRow, type CorrectEntityRequest, type CorrectionRecordDto, type CorrelationRequest, type CorrelationResponse, type CosineShape, type CountAuditEntriesResponse, type CounterfactualRequest, type CounterfactualResponse, type CounterfactualTraceDto, type CoverageCertificate, type CreateAgentRequest, type CreateAgentResponse, type CreateChildNamespaceRequest, type CreateCognitiveSortRequest, type CreateCognitiveSortResponse, type CreateCollectionRequest, type CreateConstraintSessionRequest, type CreateConstraintSessionResponse, type CreateCurriedFunctionRequest, type CreateExecutionSessionRequest, type CreateFlowNetworkRequest, type CreateGoalRequest, type CreateGoalResponse, type CreateModuleRequest, type CreateModuleResponse, type CreateOversightSessionRequest, type CreateOversightSessionResponse, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateRootNamespaceRequest, type CreateRuleStoreRequest, type CreateScenarioRequest, type CreateScenarioResponse, type CreateSnapshotRequest, type CreateSortRequest, type CreateSpaceRequest, type CreateStoreTermRequest, type CreateSubscriptionRequest, type CreateSubscriptionResponse, type CreateTenantRequest, type CreateTenantResponse, type CreateTermInCollectionRequest, type CreateTermRequest, type CreateTermStoreRequest, type CreateVariableRequest, type CrossSectionForecast, type CtlCounterExample, type CtlFormula, type CuriosityTargetDto, type CurriedFunctionResponse, type CurryingContextResponse, type CutRequest, type CutResponse, type CycleDto, type CycleOutcomeDto, type CycleOutcomeSummaryDto, type CyclicGaussianShape, dl as DL, type DSeparatedRequest, type DSeparatedResponse, type DataGroup, type DataMixingStatsDto, type DataPointDto, type DatasetStatisticsDto, type DateTimeValue, type DecisionAuditRequest, type DecisionAuditResponse, type DeclareLatentVariableRequest, type DeclareLatentVariableResponse, type DecodeGlbResponse, type DeepCopyRequest, type DegreeDistributionDto, type DeleteAgentResponse, type DeleteGoalResponse, type DeletePlanRequest, type DeletePlanResponse, type DeleteSnapshotResponse, type DeleteSortResponse, type DeleteSortRulesDisposition, type DeleteSortTermsDisposition, type DeleteSpeakerRequest, type DeleteTenantResponse, type DeleteTermReport, type DeliveryStatusDto, demo as Demo, type DemoSeedRequest, type DemoSeedResponse, type DensityRatioDiagnosticDto, type DependentInfoDto, type DeprecateSortRequest, type DereferenceRequest, type DereferenceResponse, type DerivationSummaryDto, type DerivedInferenceRequest, type DerivedInferenceResponse, type DerivedInferenceResultDto, type DetectCommunitiesRequest, type DetectCommunitiesResponse, type DetectMissingAttributesRequest, type DiDValidationRequest, type DiDValidationResponse, type DiagnosticDto, type DiagnosticsResponse, type DifferentiableFcRequest, type DifferentiableFcResponse, type DiscoverCausalRequest, type DiscoverCausalResponse, type DiscoverEffectsRequest, type DiscoverEffectsResponse, type DiscoverEmlRequest, type DiscoverEmlResponse, type DiscoverSchemaRequest, type DiscoverSchemaResponse, type DiscoverableTypeDto, type DiscoveredFeatureDto, type DiscoveredRelationDto, type DiscoveredSortDto, type DiscoveredSourceRelationDto, discovery as Discovery, type DiscoveryConfigDto, type DiscoveryProofNodeDto, type DiscoveryProofStatsDto, type DiscoveryProofTreeDto, type DiscoveryStateDto, type DiscoveryStatusResponse, type DiscoveryStrategy, type DisentailmentRequest, type DisentailmentResponse, type DiversityAnalysisDto, type DlSatisfiableRequest, type DlSatisfiableResponse, type DlSubsumesRequest, type DlSubsumesResponse, type DmlAteRequest, type DocumentAnalysisReport, type DocumentBatchItem, type DocumentBatchResultDto, documentCheck as DocumentCheck, type DocumentExtractedEntity, type DocumentGraph, type DocumentGraphCommunity, type DocumentGraphEdge, type DocumentGraphNode, type DocumentGraphQuery, type DocumentInput, type DocumentMetadataDto, type DocumentParseStatsDto, type DocumentParser, type DocumentProgressDto, type DocumentProofStep, type DocumentQaPair, type DocumentRecord, type DocumentResult, type DocumentRuleResult, type DocumentRuleSeverity, type DocumentRuleStatus, type DocumentSource, type DocumentStatsDto, type DocumentStatus, type DocumentSummary, type DocumentType, type DocumentVersionsResponse, documents as Documents, type DomainValue, type DoseResponseRequest, type DoseResponseResponse, type DraftFunctionRequest, type DraftFunctionResponse, type DraftRulesRequest, type DraftRulesResponse, type DriveDeficitDto, type DriveDto, type DynamicAddSortRequest, type DynamicAddSortResponse, type DynamicDiscoveryRequest, type DynamicDiscoveryResponse, type DynamicQueryClauseDto, type DynamicQueryGroupDto, type DynamicQueryRequest, type DynamicQueryResponse, type DynamicQueryResultDto, type E2ETrainingRequest, type E2ETrainingResponse, type EdgeCapacityUpdate, type EdgeClass, type EdgeClassification, type EdgeFlow, type EdgeSpec, type EdgeTypeDto, type EffectDto$1 as EffectDto, type EffectPredictionDto, type EmbeddingRankRequest, type EmbeddingRankResponse, type EmbeddingVerificationResponse, embeddings as Embeddings, type EmlSample, type EncodeClipRequest, type EncodeClipResponse, type EncoderConfigOverrides, type EndSchedulingResponse, type EnforcementStrategy, type EnrichedHealthResponse, type EnrollSpeakerRequest, type EnrollSpeakerResponse, type EnrollVoiceRequest, type EntailmentRequest, type EntailmentResponse, type EntityDto, type EntityVerificationDetailDto, type EpisodeDto, type EpisodeOutcomeDto, type EpisodeStatsResponse, type EqLiteralDto, type EqualityAtomDto, type EquivalenceClass, type EquivalenceClassDto, type ErrorResponse$1 as ErrorResponse, type EvalBuiltinRequest, type EvalBuiltinResponse, type EvalFunctionInfoDto, type EvaluateFunctionRequest, type EvaluateFunctionResponse, type EvaluatePatternRequest, type EvaluatePatternResponse, type EvaluatedValueDto, type EvaluationResult, type EvidenceAssessmentRequest, type EvidenceAssessmentResponse, type EvidenceDerivationConfigDto, type EvidenceItemDto, type EvidenceItemSummaryDto, type EvidenceSourceDto, execution as Execution, type ExecutionGoalDto, type ExecutionSessionResponse, type ExecutionSessionStatsResponse, type ExecutionValueDto, type ExogenousNoiseDto, type ExplorationCompleteResponse, type ExplorationProgress, type ExplorationQuestion, type ExplorationStatusResponse, type ExportJsonlResponse, type ExpressionDto, type ExtendedAgentStateDto, type ExternalActionSummaryDto, type ExternalMatchDto, type ExternalRefValue, extract as Extract, type ExtractEntitiesRequest, type ExtractEntitiesResponse, type ExtractImageRequest, type ExtractImageResponse, type ExtractedEntityDto, type ExtractionPredictionDto, type ExtractionStatsDto, type ExtractionStrategy, type ExtractionStrategyAdaptive, type ExtractionStrategyHybrid, type ExtractionStrategyLlm, type ExtractionStrategyLocalNer, type ExtractionStrategySchemaGuided, type FactConfidenceEntry, type FactoryResetResponse, type FailedReviewDto, type FdDomainStateDto, feasibility as Feasibility, type FeatureBindingDto, type FeatureChangeDto, type FeatureConfigDto, type FeatureDescriptorDto, type FeatureFilterDto, type FeatureInputConstrainedVariable, type FeatureInputInlineTerm, type FeatureInputInlineTermByName, type FeatureInputSortRef, type FeatureInputTermRef, type FeatureInputValueDto, type FeatureInputVariable, type FeatureMismatchDto, type FeaturePair, type FeatureRequirementDto, type FeatureTargetDto, type FeatureTypeDto, type FeatureValueDto, type FinalizeOversightSessionRequest, type FindBySortRequest, type FindPlansRequest, type FindPlansResponse, type FindRulesRequest, type FindRulesResponse, type FindSimilarRequest, type FindallRequest, type FindallResponse, type FindingKind, type FindingSeverity, type FixSuggestionDto, Flow, type FlowAlgorithm, type FlowProblem as FlowBuilderProblem, type FlowEdgeInput, type FlowEdgeOptions, type FlowNetworkResponse, flowNetworks as FlowNetworks, type FlowNode, type FlowProblemInputBase, type FocusEntryDto, type ForallRequest, type ForallResponse, ForbiddenError, forecast as Forecast, type ForecastAbstention, type ForecastBody, type ForecastCertificate, type ForecastCoveringSet, type ForecastDomain, type ForecastDomainsResponse, type ForecastEntityInput, type ForecastRequest, type ForecastResponse, type FormalJudgeRefinementResponse, type FormalJudgeRequest, type FormalJudgeResponse, type FormalVerdictDto, type ForwardChainRequest, type ForwardChainResponse, type FoundryReviewItemDto, type FrameSummary, type FrequencyEstimate, type FrequencyRequest, type FrequencyResponse, type FrontDoorObservationDto, type FrontDoorRequest, type FrontDoorResponse, type FunctionBodyDto, type FunctionCaller, type FunctionCallerKind, type FunctionCallersDisposition, type FunctionClauseDto, type FunctionDefinitionSignature, type FunctionDraftDto, type FunctionGuardDto, type FunctionKindDto, type FunctionNotReplaceableDto, type FunctionSummaryDto, type FunctionType, type FunctionTypeListResponse, type FunctionValueDto, type FunctionWithdrawalReport, functions as Functions, fuzzy as Fuzzy, type FuzzyConceptLevel, type FuzzyMergeRequest, type FuzzyMergeResponse, type FuzzyNumberValue, type FuzzyProveRequest, type FuzzyProveResponse, type FuzzyScalarValue, type FuzzySearchResultItem, type FuzzySearchTopKRequest, type FuzzySearchTopKResponse, FuzzyShape, type FuzzyShapeDto, type FuzzySubsumptionRequest, type FuzzySubsumptionResponse, type FuzzyUnifyRequest, type FuzzyUnifyResponse, type GESResultDto, type GFlowNetSampleRequest, type GFlowNetSampleResponse, type GFlowNetTrainResponse, type GateRequest, type GateResponse, type GaussianProductShape, type GaussianShape, type GenMode, type GeneralConstraintDto, type GenerateDocumentRequest, type GenerateDocumentResponse, type GenerateNegativesRequest, type GenerateNegativesResponse, type GenerateOntologyRequest, type GenerateOntologyResponse, type GenerateSyntheticDataRequest, type GenerateSyntheticDataResponse, generation as Generation, type GenerationPromptRequest, type GenerationPromptResponse, type GenerationProvenanceDto, type GenerationReportDto, type GenerationVerificationDto, type GenericModelRequest, Geometry, type GeometryDto, type GeometryValue, type GetAgentDrivesRequest, type GetAgentStateRequest, type GetAgentStateResponse, type GetBindingsRequest, type GetCausalModelResponse, type GetEpisodeStatsRequest, type GetEquivalenceClassesResponse, type GetExtendedAgentStateRequest, type GetExtendedAgentStateResponse, type GetFactsResponse, type GetFunctionResponse, type GetFuzzySubsumptionRequest, type GetFuzzySubsumptionResponse, type GetInboxRequest, type GetInboxResponse, type GetMembershipsRequest, type GetMembershipsResponse, type GetPreorderDegreeRequest, type GetPreorderDegreeResponse, type GetResiduationsRequest, type GetResiduationsResponse, type GetRulesResponse, type GetScenarioResponse, type GetSortSimilarityRequest, type GetSortSimilarityResponse, type GetStoreTermRequest, type GetStoreTermResponse, type GlbLubComputationTrace, type GlbLubOperation, type GlbLubTraceRequest, type GlbLubTraceStep, type GlbRequest, type GlbResponse, type GlobalAssignRequest, type GlobalAssignResponse, type GlobalGetRequest, type GlobalGetResponse, type GlobalIncrementRequest, type GlobalIncrementResponse, type GoalDto, type GoalEvaluationResultDto, type GoalResiduationRequest, type GoalResiduationResponse, type GoalStackEntryDto, type GoalStackResponse, type GoalStatusUpdate, type GoalSummaryDto, type GraphEdgeDto, type GraphExportFormat, type GraphMetadataDto, type GraphNodeDto, type GraphSparqlQueryRequest, type GraphSparqlResults, type GroundTruthEntry, type GroundTruthStatus, type GroundedGenerateRequest, type GroundedGenerateResponse, type GroundedSchemaResponse, type GroundingStatsDto, type GroupedRankForecast, type GuardOp, guardrail as Guardrail, type GuardrailReport, type GuardrailRequest, type GuardrailSummary, health as Health, type HeavyHitterItem, type HeavyHittersRequest, type HeavyHittersResponse, type HipaaIdentifier, homoiconic as Homoiconic, type HomoiconicSubstitutionDto, type HorizonDto, type HtnMethodDto, type HyperedgeDto, type HyperedgeTypeDto, type HypergraphRequest, type HypergraphResponse, type HypergraphStats, ilp as ILP, type IdentificationRefDto, type IdentifyEffectRequest, type IdentifyEffectResponse, type ImageExtractedEntityDto, type ImageExtractedRelationDto, imageExtraction as ImageExtraction, type ImageExtractionStatsDto, type ImageSuggestedSortDto, type ImpasseDto, type Implication, type ImpliesRequest, type ImpliesResponse, type ImportFoundryRequest, type ImportFoundryResponse, type ImportModuleRequest, type ImportModuleResponse, type ImportOwlRequest, type ImportOwlResponse, type InboxMessageDto, type IncompleteDocumentDto, type InfeasibleResult, inference as Inference, type InfluenceDto, type IngestDocumentBatchRequest, type IngestDocumentBatchResponse, type IngestDocumentRequest, type IngestDocumentResponse, type IngestFromSourceRequest, type IngestFromSourceResponse, type IngestKifRequest, type IngestKifResponse, type IngestMarkdownBatchRequest, type IngestMarkdownRequest, type IngestMarkdownResponse, type IngestPaperRequest, type IngestPaperResponse, type IngestRdfRequest, type IngestRdfResponse, type IngestStepRequest, ingestion as Ingestion, type IngestionConfigDto, IngestionFailedError, type IngestionPollOptions, IngestionSession, type IngestionSessionResponse, type IngestionSessionStatusDto, type IngestionStatsDto, type IngestionSyncOptions, type InlineDocument, type InstallList, type InstallPluginRequest, type InstallPluginResponse, type InstallState, type InstallSummary, type IntegerValue, type IntegratedCycleOutcomeDto, type IntegratedEngineConfigDto, type IntegrationGroupDto, type IntegrityResponse, type IntentionDto, type InteractionGraphDto, type Interceptor, type InterfaceType, type InterfaceTypeListResponse, InternalServerError, type InterventionDto, type InterventionObservationRequest, type InterventionObservationResponse, type InterventionRecommendationDto, type InterventionRequest, type InterventionResponse, type InvokeActionRequest, type InvokeActionResponse, type IterationMetricDto, type JsonValue$1 as JsonValue, type JudgeConfigDto, type KAnonymityResult, type KAnonymityViolation, type KBOptimizationConfig, type KBOptimizationResult, type KBResourceConstraint, type KBVariableSpec, type KbChangeDto, type KbChangeType, type KeyProvenanceDto, type KnowledgeGapDto, type KripkeState, type KripkeTransition, LP, ltn as LTN, type LatticeStats, type LatticeVisualizationRequest, type LatticeVisualizationResponse, type LayerResultDto, type LayerResultSummaryDto, type LayoutAlgorithmDto, type LayoutDirectionDto, type LayoutHintsDto, type LayoutModeDto, type LayoutSlotDto, type LayoutSurfaceDto, type LazyEvalRequest, type LazyEvalResponse, type LearnFromCorrectionRequest, type LearnFromCorrectionResponse, type LearnPatternConfigDto, type LearnPatternRequest, type LearnPatternResponse, type LearnSortSimilaritiesRequest, type LearnSortSimilaritiesResponse, type LearnedPatternDto, type LearnedSimilarityDto, type LearnedSimilarityListResponse, type LearnedSimilarityProvenanceDto, type LearnedSimilarityStatusDto, type LedgerInfoDto, type LinExpr, type LinTerm, type LinearConstraint$1 as LinearConstraint, type LinearExpression, type LinearProgramDefinition, type LinkPredictionRequest, type LinkPredictionResponse, type LinkType, type LinkTypeListResponse, type ListActionReviewsOptions, type ListActionReviewsResponse, type ListAgentsResponse, type ListAuditEntriesQuery, type ListAuditEntriesResponse, type ListAuditOptions, type ListBindingsResponse, type ListCatalogParams, type ListConversationsResponse, type ListDocumentsQuery, type ListDocumentsResponse, type ListEnginesResponse, type ListEvalFunctionsRequest, type ListEvalFunctionsResponse, type ListExternalActionsResponse, type ListFunctionsResponse, type ListGoalsResponse, type ListIncompleteDocumentsResponse, type ListIngestionSessionsResponse, type ListInstallsParams, type ListLevelsResponse, type ListPatternsResponse, type ListPendingInvocationsResponse, type ListPendingReviewsOptions, type ListPreferencesResponse, type ListResearchSessionsResponse, type ListScenariosResponse, type ListSnapshotsResponse, type ListSourceTypesResponse, type ListSourcesResponse, type ListSpeakersResponse, type ListSubscriptionsResponse, type ListSymbolsRequest, type ListSymbolsResponse, type ListTablesResponse, type ListTenantsResponse, type ListTermsQuery, type ListValue, type ListVoicesResponse, type Lit, type LiteralFeatureValue, type LiteralInputDto, type LogOddsAntecedentContributionDto, type LogOddsScoreDecompositionDto, type LogOddsWitnessDto, type LtnAggregator, type LtnAggregatorKind, type LtnFeatureText, type LtnInstance, type LtnLearnedCertainty, type LtnPredicateExample, type LtnPredicateFit, type LtnPredicateTraining, type LtnQueryKind, type LtnQueryRequest, type LtnQueryResponse, type LtnRefuteRequest, type LtnRefuteResponse, type LtnRule, type LtnTrainRequest, type LtnTrainResponse, type LtnWitnessEntry, type LubRequest, type LubResponse, type MarkChoicePointRequest, type MarkMessagesReadRequest, type MarkMessagesReadResponse, type MarkPendingRequest, type MarkPendingResponse, type MarkRuleStoreRequest, type MarkRuleStoreResponse, type MarkTermStoreRequest, type MarkTermStoreResponse, type MarkdownDocumentDto, marketplace as Marketplace, type MarketplaceScope, type MatchedEntityDto$1 as MatchedEntityDto, type MaterializationSummaryDto, type MaterializeScenarioRequest, type MaterializeScenarioResponse, type MathFunctionRequest, type MathFunctionType, type MaxFlowInput, type MaxFlowVars, type MeasurementRole, type MeasurementUnitDto, type MeasurementValue, type MediationDmlRequest, type MediationEffectDto, type MediationObservationDto, type MediationRequest, type MediationResponse, type MeetPreservationDto, type MembershipDto, type MembershipRequest, type MembershipResponse, type MembershipResult, type MergeEntityRequest, type MetaSortsResponse, type MinCostMaxFlowInput, type MinCostMaxFlowVars, type MinCutInput, type MinCutReport, type MinCutVars, type MissingInfoDto, type ModifyActionRequest, type ModularArithRequest, type ModularOperationType, type MonadicFactDto, type MonadicFixpointRequest, type MonadicFixpointResponse, type MotivationStateDto, type MoveDto, type MultiMediationObservationDto, type MultiMediationRequest, type NafProveRequest, type NafProveResponse, type NafResponse, type NamespaceDto, type NamespaceListResponse, type NamespaceResponse, namespaces as Namespaces, type NegativeExampleDto, NetworkError, neuroSymbolic as NeuroSymbolic, type NeuroSymbolicStatusResponse, type NlQueryMode, type NlQueryRequest, type NlQueryResponse, type NlQueryResultItem, type NodeScore, type NodeTypeDto, NotFoundError, type NumberFormatDto, type NumberToStringRequest, type NumberValueDto, type NumberedPage, type NumberedPageReader, type OAuthCallbackQuery, type OAuthStartResponse, type ObjectType, type ObjectTypeListResponse, type Objective, type ObjectiveFunction, type ObjectiveSense, type ObservationDto, type ObservationalProbabilitiesDto, type ObserveMultiRequest, type ObserveMultiResponse, type ObservePairRequest, type ObservePairResponse, type ObserveSingleRequest, type ObserveSingleResponse, type OcrConfigDto, type OffsetPage, type OffsetPageReader, ontology as Ontology, ontologyAlignment as OntologyAlignment, ontologyBridge as OntologyBridge, type OntologyClarificationQuestionDto, ontologyExport as OntologyExport, type OntologyExportDocument, type OntologyExportFormat, type OntologyExportOptions, ontologyFacade as OntologyFacade, type OntologyRagRequest, type OntologyRagResponse, type OntologyRagStatsDto, type OpenSpeechSessionRequest, type OpenSpeechSessionResponse, type Operand, operations as Operations, type OptimalResult, type OptimizationDirection, type OptimizationResult, optimize as Optimize, type OrderedCombo, type OrientPairDiagnosticsDto, type OrientPairDirectionDto, type OrientPairFitDto, type OrientPairIndependenceTestRequest, type OrientPairRegressionBasisDto, type OrientPairRegressionRequest, type OrientPairRequest, type OrientPairResponse, type OrientPairVerdictDto, osfDiff as OsfDiff, type OsfDiffReport, type OsfDiffRequest, type OsfDiffResponse, type OsfDiffSelector, type OsfDiffSequenceReport, type OsfDiffSequenceRequest, type OsfDiffSequenceResponse, type OsfDiffTemporalRequest, type OsfSearchRequest, type OsfSearchResponse, type OsfSearchStatsDto, osfql as Osfql, type OsfqlCatalogEntry, type OsfqlCatalogExecution, type OsfqlCatalogUiAffinity, type OsfqlDiagnoseRequest, type OsfqlDiagnoseResponse, type OsfqlDiagnostic, type OsfqlRange, type OsfqlRequest, type OsfqlResponse, type OsfqlTermValue, type OsfqlValue, type OutputFormatDto, type OverlapDiagnosticDto, oversight as Oversight, type OversightAlertDto, type OversightSessionStatusResponse, type PaginateOptions, type PaginationParams, type PaperMetadataDto, type PaperRefDto, type PaperSearchResultDto, type PaperSource, type ParamSpec, type ParsedDocumentMetadataDto, type PartialCorrelationRequest, type PartialCorrelationResponse, type PatchSortFeatureRequest, type PatchSortRequest, type PathRequest, type PathResponse, type PathwaysDto, type PatternDto, type PatternSummaryDto, type PendingActionReviewDto, type PendingInvocationDto, type PendingReviewDto$1 as PendingReviewDto, type PiShapeShape, type PiecewiseLinearShape, type Pin, type PipelineQualityStatsDto, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, type PlanMatchDto, type PluginDependency, type PluginDetail, type PluginManifest, type PluginSummary, type PluginVersion, type Point2DGeometry, type PolicyRowDto, type PolicyRuleDto, type PolicyValueRequest, type PolicyValueResponse, type PolygonGeometry, type PositionalArgumentDto, type PredictEffectRequest, type PredictEffectResponse, type PredictFromDiscoveryRequest, type PredictFromDiscoveryResponse, type PredictPreferencesRequest, type PredictPreferencesResponse, type PredictionEntry, type PredictionErrorDto, type PredictionInterval, type PredictionSnapshot, type Preference, type PreferenceDto, type PreferencePrediction, preferences as Preferences, type PrerequisiteInfoDto, type ProbabilityBoundDto, type ProofDto, proofEngine as ProofEngine, type ProofEngineCreateTermResponse, type ProofExportFormat, type ProofExportRequest, type ProofExportResponse, type ProofExportResult, type ProofKind, type ProofLiteralDto, type ProofNodeDto, type ProofStatisticsDto, type ProofTraceDto, type ProofTraceNodeDto, type Property, propertyGraph as PropertyGraph, type PropertyGraphErrorResponse, type PropertyGraphExecuteResponse, type PropertyGraphQueryRequest, type PropertyGraphTranslateResponse, type PropertyGraphValue, type ProvenanceStepDto, type ProvenanceTagDto, type ProvideFeedbackRequest, type ProvideFeedbackResponse, type PsiTermDto, type PsiTermInput, type PsiTermInputById, type PsiTermInputByName, type PsiTermValue, type PublishPluginRequest, type PublishPluginResponse, type PushGoalRequest, type PushGoalResponse, type QuasiIdentifier, query as Query, type QueryResultDto, type QueryTerm, rag as RAG, type RankedInstrument, RateLimitError, type RateLimitInfo, type RawGenerateRequest, type RawGenerateResponse, type RdfFormatDto, type ReExtractRequest, type ReachableDto, type ReachedEdgeDto, type ReachedStateDto, type ReadableTermDto, type ReadableTermsResponse, type RealValue, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type ReasoningStageDto, type ReasoningTraceDto, type RecallEpisodesRequest, type RecallEpisodesResponse, type RecalledEpisodeDto, type RecordEpisodeRequest, type RecordEpisodeResponse, type RecordSafeHarborStatus, type RecordSelectionRequest, type RecordSelectionResponse, type RecordTurnRequest, type RecordTurnResponse, type ReferenceValue, type ReferencedTermSummary, type ReflectionQueryRequest, type ReflectionQueryResponse, type RefutationCheckDto, type RefutationObservationDto, type RefuteEstimateRequest, type RefuteEstimateResponse, type RefuteRequest, type RefuteResponse, type RegisterExternalActionRequest, type RegisterExternalActionResponse, type RegisterFunctionRequest, type RegisterFunctionResponse, type RegisterSourceRequest, type RegisterSourceResponse, type RegressionBasis, type RejectActionRequest, type RejectEntityRequest, type RejectLearnedSimilarityRequest, type RejectLearnedSimilarityResponse, type RelOp, type RelOpDto, type RelatedInfoDto, type RelationTypeDto, type RelationalArithRequest, type ReleaseResiduationsRequest, type ReleaseResiduationsResponse, type RemoveSortFeatureOptions, type ReplaceFunctionResponse, type ReplaceRuleResponse, type ReportVerificationDto, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchCycleResultDto, type ResearchFindingDto, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, type ResearchSessionStatusDto, type ResearchSessionSummaryDto, type ResearchStatisticsDto, type ResidualWitnessDto, type ResiduateGoalRequest, type ResiduateGoalResponse, type ResiduatedEntryDto, type ResiduatedFeatureDto, type ResiduatedTermDto, type ResiduationDetailDto, type ResiduationDto, type ResiduationGoalDto, type ResiduationKind, type ResiduationRequest, type ResiduationResponse, type ResiduationStateDto, type ResiduationStateFilter, type ResiduationStateRequest, type ResiduationStateResponse, type ResiduationStats, type ResolutionStrategyDto, type ResolveSymbolRequest, type ResolveSymbolResponse, type ResolvedCoreferenceDto, type ResourceCoordinationRequest, type ResourceCoordinationResponse, type ResourceSpec, type ResumeDocumentIngestionRequest, type ResumeDocumentIngestionResponse, type ResumptionOptionDto, type RetentionDto, type RetractRuleRequest, type RetractRuleResponse, type RetrievalStatsDto, type ReviewCandidateMatchDto, type ReviewReason, reviews as Reviews, reward as Reward, type RewardObjective, type RewardScoreRequest, type RewardScoreResponse, type RiskTier, type RlPolicyConfigDto, type RlPolicyWeightsDto, type RlPolicyWeightsUploadResponse, type RlTrainRequest, type RlTrainResponse, type RootCauseAnalysisRequest, type RootCauseAnalysisResponse, type RootCauseDto, type RootCauseWithProofResponse, row as Row, type RowIntegrateRequest, type RowIntegrateResponse, type RowMatchDto, type RowSearchRequest, type RowSearchResponse, type RowSimilarityRequest, type RowSimilarityResponse, type RowTypeDto, type RowUnifyRequest, type RowUnifyResponse, type RuleAggregatorDto, type RuleBaseCertificateDto, type RuleCertificationDelta, type RuleClauseDto, type RuleConstraintDto, type RuleDerivationsDisposition, type RuleDraftClarificationQuestionDto, type RuleDraftDto, type RuleDto, type RuleEntryDto, type RuleNotWithdrawable, type RuleOrigin, type RuleStoreResponse, type RuleTermDraftDto, type RuleUtilityDto, type RuleWithdrawalReport, type RunAgentRequest, type RunCycleRequest, type RunCycleResponse, type RunIntegratedCycleRequest, type RunIntegratedCycleResponse, SDK_VERSION, type SShapeShape, type SafeHarborSummary, type SafetyModelInfoDto, type SampledHypothesisDto, sat as Sat, type SatLiteralDto, type SatSatisfiableResult, type SatSolveRequest, type SatSolveResponse, type SatSolverStatsDto, type SatUnknownResult, type SatUnsatisfiableResult, type SatVerdict, type SaveWeightsResponse, type ScenarioSummaryDto, scenarios as Scenarios, scheduling as Scheduling, type SchedulingDeltaResponse, type SchedulingFeasibilityRequest, type SchedulingFeasibilityResponse, type SchedulingOptimizeRequest, type SchedulingOptimizeResponse, type SchedulingSessionResponse, type SchedulingStatus, type SchemaExcerptDto, type ScmCounterfactualRequest, type ScmCounterfactualResponse, type ScoreTermsRequest, type ScoreTermsResponse, type ScoredTerm, type SearchCatalogRequest, type SearchCatalogResponse, type SearchCommunitiesRequest, type SearchCommunitiesResponse, type SearchModeDto, type SearchPapersRequest, type SearchPapersResponse, type SearchSortsBy, type SearchSortsMatch, type SearchSortsRequest, type SearchSortsResponse, type SearchStatsDto, type SearchStrategyDto, type SendMessageRequest, type SendMessageResponse, type SensitivityDto, type SeriesEpochUnit, type SeriesMissingPolicy, type SeriesOperator, type SeriesTimeSource, type SeriesValueSource, type SeriesWindowSpec, type SessionGraphDto, type SessionProgressResponse, type SessionStatsResponse, type SetActionReviewConfigRequest, type SetActionReviewConfigResponse, type SetFeatureRequest, type SetFeatureResponse, type SetFuzzySubsumptionRequest, type SetFuzzySubsumptionResponse, type SetGoalStatusRequest, type SetGoalStatusResponse, type SetPreferenceRequest, type SetSortSimilarityRequest, type SetSortSimilarityResponse, type SetValue, type ShiftDemand, type ShiftEffectRequest, type ShiftEffectResponse, type SigmoidDifferenceShape, type SigmoidProductShape, type SigmoidShape, type SimilarityEntryDto, type SimilarityMatch, type SimilaritySearchResponse, type SimpleTgdDto, type SingleCopyRequest, type SketchDimensions, smt as Smt, type SmtCheckRequest, type SmtCheckResponse, type SmtFunctionApplicationDto, type SmtSatResult, type SmtUnknownResult, type SmtUnsatResult, type SmtVerdict, type SnapshotFilter, type SnapshotResponse, snapshots as Snapshots, type SoftUnifyRequest, type SoftUnifyResponse, type SolutionDto, type SolutionStatus, type SolveConstraintRequest, type SolveConstraintResponse, type SolveFlowNetworkRequest, type SolveFlowNetworkResponse, type SolveOptions, type SolveProblemRequest, type SolveProblemResponse, solver as Solver, type SolverHealthResponse, type SolverHint, type SortBoxRequest, type SortBoxResponse, SortBuilder, type SortCalibrationDto, type SortCompareOperator, type SortCompareRequest, type SortCompareResponse, type SortDiscoveryRequest, type SortDiscoveryResponse, type SortDto, type SortFeatureEditResponse, type SortIdValue, type SortIndexStatusResponse, type SortInfoDto, type SortListResponse, type SortOriginDto, type SortRecommendation, type SortReferenceKind, type SortReferencingRuleDto, type SortResponse, type SortSimilarityResponse, type SortStatusDto, type SortSuggestionDto, type SortSummaryDto, sorts as Sorts, type SortsSchemaQuery, type SourceDetailResponse, type SourceExcerptDto$1 as SourceExcerptDto, type SourceSummaryDto, type SourceTypeDto, type SourceWriteMode, sources as Sources, type SpaceConstraintDto, type SpaceResponse, type SpaceSearchRequest, type SpaceSearchResponse, type SpaceSolutionDto, type SpaceStatusDto, spaces as Spaces, sparql as Sparql, type SparqlAskResults, type SparqlBindingSet, type SparqlEntailmentRegime, type SparqlOrderByKey, type SparqlOsfqlLeaf, type SparqlPlanNode, type SparqlQueryForm, type SparqlQueryRequest, type SparqlQueryResults, type SparqlRdfTerm, type SparqlSelectResults, type SparqlTranslation, type SparqlTripleTermValue, type SparqlUpdateRequest, type SparqlUpdateTranslation, type SpeakerProfile, speakers as Speakers, type SpecificityDto, speech as Speech, type SpeechEngine, type SpikeShape, type StartExplorationRequest, type StartExplorationResponse, type StartIngestionSessionRequest, statistical as Statistical, type StatisticalSuccessResponse, type StepLogEntryDto, type StepVerificationResponse, type StorePlanRequest, type StorePlanResponse, streaming as Streaming, type StringCompareOperator, type StringComparePredicateRequest, type StringCompareRequest, type StringConcatRequest, type StringLengthRequest, type StringOpParams, type StringOpRequest, type StringOperationType, type StringValue, type StructuralAssignmentDto, type StructuredIngestionStatsDto, type SubscribeToKbRequest, type SubscribeToKbResponse, type SubscriptionDto, type SubscriptionEventKind, subscriptions as Subscriptions, type SubstringRequest, type SummaryResponse, type SuspendedQueryDto, type SymbolDto, type SymbolKindDto, type SymbolicResultDto, type SynthesizeRequest, type SynthesizeResponse, type SynthesizeSpeechRequest, synthetic as Synthetic, type SystemGroup, type TaggedDerivedFact, type TaggedFactDto, type TaggedFcRequest, type TaggedFcResponse, type TaggedFeatureValueDto, type TaggedForwardChainRequest, type TaggedForwardChainResponse, temporal as Temporal, type TemporalModelCheckRequest, type TemporalModelCheckResponse, type TemporalPlanRequest, type TemporalPlanResponse, type TemporalPoint, type TemporalRule, type TemporalSeries, type TemporalSeriesPoint, type TemporalSeriesRequest, type TemporalSeriesResponse, type TemporalSeriesSpec, type TemporalTrendSummary, type TenantInfoDto, type TermBindingDto, type TermDto, type TermEdit, type TermInputArg, type TermInputDto, type TermInputInline, type TermInputInlineByName, type TermInputRef, type TermListResponse, type TermOrigin, type TermPatternDto, type TermRefFeatureValue, type TermReferencesDisposition, type TermReferrerDto, type TermReferrersResponse, type TermResponse, type TermSetSelector, type TermState, type TermStoreSessionResponse, type TermVersionDto, type TermVersionsResponse, type TerminationDto, terms as Terms, type TestInput, thomas as Thomas, type ThomasPathwaysRequest, type ThomasStudyRequest, type ThomasStudyResponse, TimeoutError, type TokenUsageDto, type ToolCallInfo, type TraceEventDto, type TrailEntryDto, type TrainFromTracesResponse, type TrainingExample, type TrainingExampleDto, type TrainingTriggerResponse, type TrajectoryStepDto, type TranscribeSpeechRequest, type TranscribeSpeechResponse, type TranslateRdfRequest, type TranslateRdfResponse, type TranslateRequest, type TranslateResponse, type TranslatedRdfTermDto, translation as Translation, type TranspileRequest, type TranspileResponse, type TrapezoidalShape, type TriangularShape, type TriggerDependencyRequest, type TriggerDependencyResponse, type TurnDto, type TypedConstraint, ui as UI, type UIActionDto, type UIActionRequest, type UIActionResponse, type UIAssemblyStatsDto, type UICatalogEntry, type UICatalogResponse, type UICustomizationDto, type UIDescribeRequest, type UIDescribeResponse, type UIDescriptorDto, type UIGenerateRequest, type UIGenerateResponse, type UiSort, type UnaryOperatorDto, type UncertainEdgeDto, type UndoRequest, type UndoResponse, type UndoRuleStoreRequest, type UndoRuleStoreResponse, type UnifiableQueryRequest, type UnificationQueryResponse, type UnifyTermsRequest, type UnifyTermsResponse, type UninstantiatedValue, type UpdateCollectionRequest, type UpdateMetadataRequest, type UpdatePlanStatsRequest, type UpdatePlanStatsResponse, type UpdateReviewStatusRequest, type UpdateScenarioRequest, type UpdateScenarioResponse, type UpdateTenantNameRequest, type UpdateTenantNameResponse, type UpdateTermRequest, type UpdateVisibilityRequest, type UpgradeInstallRequest, utilities as Utilities, type ValidateTermRequest, type ValidatedTermResponse, type ValidatedUnifyRequest, type ValidatedUnifyResponse, ValidationError, type ValidationReportDto, type ValidationRuleDto, type ValidationTypeDto, Value, type ValueDto, type ValuePatternDto, values as Values, type VarKind, type VariableBounds, type VariableClassification, type VariableDto, type VariableFeasibilityDto, type VariableFeatureValue, type VariableSpec, type VerbalizationResultDto, type VerbalizeTermRequest, type VerbalizeTermResponse, verification as Verification, type VerificationStepDto, type VerifyClaimRequest, type VerifyClaimResponse, type VerifyFaithfulnessRequest, type VerifyFaithfulnessResponse, type VerifyResponse, type VerifyRoundTripRequest, type VerifyRoundTripResponse, type VerifyScenarioRequest, type VerifyScenarioResponse, type VersionDiffDto, type ViolationCountsDto, type ViolationDto, type VisibilityDto, vision as Vision, visualization as Visualization, type VisualizationGraphDto, type VoiceConsent, type VoiceProfile, type WaitingConditionDto, type WaitingConditionType, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WebhookCallbackRequest, type WebhookCallbackResponse, type WeightedFactDto, type WitnessInstantiationDto, type WitnessProofDto, type WorkflowGroup, type WorldModeDto, type YankPluginRequest, type YankPluginResponse, type ZShapeShape, allen, bind, collect, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, paginateByOffset, paginateByPage, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };
+export { ANY_ROLE, type ActValueDto, type ActionParamRule, type ActionParameter, type ActionReviewReasonDto, type ActionReviewReasonFilter, type ActionReviewResponse, type ActionReviewStatusDto, type ActionReviewSummaryDto, actionReviews as ActionReviews, type ActionSideEffect, type ActionType, type ActionTypeDef, type ActionTypeListResponse, actions as Actions, type ActivationDto, type AdaptiveModifyRequest, type AdaptiveModifyResponse, type AddBeliefRequest, type AddBeliefResponse, type AddCausalRelationRequest, type AddCausalRelationResponse, type AddCognitiveRuleRequest, type AddCognitiveRuleResponse, type AddConnectorRequest, type AddConnectorResponse, type AddConstraintsRequest, type AddConstraintsResponse, type AddExportRequest, type AddFactRequest, type AddFactResponse, type AddGoalRequest, type AddGoalResponse, type AddHtnMethodRequest, type AddHtnMethodResponse, type AddImportRequest, type AddPendingReviewRequest, type AddRuleRequest, type AddRuleResponse, type AddSymbolRequest, type AddSymbolResponse, admin as Admin, type AdmissibleDto, type AffectedPreviewDto, type AgentBeliefDto, type AgentConfigDto, type AgentEvent, type AgentEventHandlers, type AgentGoalDto, type AgentRecallAsOfRequest, type AgentRecallAsOfResponse, type AgentSpec, type AgentStateDto, type AgentSubVerdictDto, type AgentSubscription, type AgentTrajectoryRequest, type AgentTrajectoryResponse, agui as Agui, type AguiContextItem, type AguiEvent, type AguiFunctionCall, type AguiMessage, type AguiRole, type AguiRunOptions, type AguiTool, type AguiToolCall, type AiGroup, type AlcConcept, type AlignOntologyRequest, type AlignOntologyResponse, type AlignmentConflictDto, type AlignmentMatchDto, type AllenRelation, analysis as Analysis, type AnalysisGroup, type AnalyzeDocumentsRequest, type AnalyzeOptions, anonymization as Anonymization, type AnonymizationMode, type AnonymizeRequest, type AnonymizeResponse, type AntiUnifyBatchRequest, type AntiUnifyBatchResponse, type AntiUnifyRequest, type AntiUnifyResponse, ApiError, type ApiResponse, type AppendAuditEntryRequest, type AppendRequest, type AppendResiduationsRequest, type AppendResiduationsResponse, type ApplyActionRequest, type ApplyActionResponse, type ApplyCurriedRequest, type ApplyCurriedResponse, type ApplySnapshotResponse, type ApproveActionRequest, type ApproveEntityRequest, type ApproveLearnedSimilarityRequest, type ApproveLearnedSimilarityResponse, type ArchitectureInfoDto, type ArithOpDto, type ArithValueDto, type ArithmeticConstraintDto, type ArithmeticExprDto, type ArithmeticOp, type ArithmeticRecursionOp, type ArtifactDto, type AscRequest, type AssembleContextRequest, type AssembleContextResponse, type AssembledConceptDto, type AssembledRelationDto, type AssemblyTokenCountsDto, type AssertRuleRequest, type AssertRuleResponse, type AssignValueDto, type Assignment, type AssignmentMechanism, type AssignmentRowDto, type AssignmentStatus, type AssumptionAuditRequest, type AssumptionAuditResponse, type AssumptionRequest, type AsyncIngestionResponse, type AteEstimateRequest, type AteEstimateResponse, type AttentionTargetDto, type AttestationDto, audit as Audit, type AuditEntryDto, type AuditPage, type AuditRecord, type AuditSortField, type AuditSortOrder, type AuditedAssumptionDto, type AugmentationTargetDto, type AuthConfig, AuthenticationError, type AuthoringClarificationQuestionDto, authz as Authz, type AuthzAction, type AuthzDryRunRequest, type AuthzDryRunResponse, type AuthzEffect, type BacktrackResponse, type BacktrackTermStoreRequest, type BacktrackTermStoreResponse, type BacktrackableAssignRequest, type BacktrackableAssignResponse, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, batch as Batch, type BatchCopyRequest, type BatchOperationDto, type BatchOperationResultDto, type BatchRequest, type BatchResponse, type BatchStringCompareRequest, type BayesianEffectDto, type BayesianPredictRequest, type BayesianPredictResponse, type BeliefDto, type BellShape, type BigIntegerValue, type BinaryOperatorDto, type BindSortRequest, type BindSortResponse, type BindTermRequest, type BindTermResponse, type BindVariableRequest, type BindVariableResponse, type BindVariablesRequest, type BindVariablesResponse, type BindingDto, type BindingSummaryDto, type BindingsResponse, type BitwiseOperationType, type BitwiseRequest, type BloomFilterStats, type BoolExpr, type BooleanValue, type BoundConstraintDto, type BoundingBoxGeometry, type BroadcastMessageRequest, type BroadcastMessageResponse, type BuildInfoDto, type BulkActionReviewResponse, type BulkAddFactsRequest, type BulkAddFactsResponse, type BulkAddRulesRequest, type BulkAddRulesResponse, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkApproveActionsRequest, type BulkApproveRequest, type BulkBindError, type BulkBindSortsRequest, type BulkBindSortsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, type BulkCreateTermsRequest, type BulkFuzzyProveRequest, type BulkFuzzyProveResponse, type BulkMergeRequest, BulkRefusedError, type BulkRejectActionsRequest, type BulkRejectRequest, type BulkRetractTermsRequest, type BulkRetractTermsResponse, type BulkRowRefusal, type BulkSetSimilaritiesRequest, type BulkSetSimilaritiesResponse, type BulkSortDefinition, type BulkSortError, type BulkSortErrorKind, type BySortQueryRequest, cdl as CDL, type CalibrateRequest, type CalibrationReportDto, type CalibrationSample, type CallOnceRequest, type CallOnceResponse, type CandidateMatchDto, type CaptureSnapshotRequest, type CardinalityOriginDto, type CascadeOptions, type CatalogPage, type CategoryProbabilityDto, type CauchyShape, causal as Causal, type CausalActionSpecDto, type CausalAnalyzeAssumptionsDto, type CausalAnalyzeDataDto, type CausalAnalyzeIndependenceTestDto, type CausalAnalyzePolicyDto, type CausalAnalyzeQuestionDto, type CausalAnalyzeQuestionKind, type CausalAnalyzeRegressionDto, type CausalAnalyzeRequest, type CausalAncestorRequest, type CausalAncestorResponse, type CausalAssumptionDto, type CausalChainDto, type CausalDecisionSpecDto, type CausalDerivationStepDto, type CausalEdgeDto, type CausalHedgeDto, type CausalProofTreeDto, type CausalRelationshipDto$1 as CausalRelationshipDto, type CausationProbabilitiesRequest, type CausationProbabilitiesResponse, type CausesRequest, type CausesResponse, type CdlComponentStatus, type CdlStatusResponse, type CdlVerificationDto, type CeilingDto, type CentralityRequest, type CentralityResponse, type CertificateDetail, type CertificateDto, type CertifiedForecast, chase as Chase, type ChaseArgDto, type ChaseAtomDto, type ChaseRunRequest, type ChaseRunResponse, type ChaseStepKindDto, type CheckDiversityRequest, type CheckDiversityResponse, type CheckDocumentRequest, type CheckDocumentResponse, type CheckFinding, type CheckSummary, type ChoicePoint, type ChoicePointDto, type ChoicePointMarkerResponse, type ChoiceSelection, type ChoiceValue, type ChrRequest, type ChunkFailureDto, type CircleGeometry, type CitationCheckDto, type CitationMarkerDto, type ClaimAnnotationDto, type ClaimAssessment, type ClaimCitation, type ClaimSubtype, type ClaimVerdict, type ClarificationQuestionDto, type Classification, type ClassificationLevelDto, type ClassifyEdgesInput, type ClassifyEdgesVars, type ClassifyProblemRequest, type ClassifyProblemResponse, type ClassifySafetyRequest, type ClassifySafetyResponse, type CleanupResponse, type CleanupSessionsResponse, type CleanupStaleSessionsParams, type ClearFactsResponse, type ClearTenantResponse, type ClearTermsResponse, type ClientConfig, type ClusteredAteRequest, type ClusteredObservationDto, type CoextensiveDefinitionDto, cognitive as Cognitive, type CognitiveGoalDto, type CognitiveStrategyDto, type CognitiveTermInput, coherence as Coherence, type CoherenceAnalyzeRequest, type CoherenceAnalyzeResponse, type CoherenceClaimDto, type CoherenceInlineDocumentDto, type CoherenceSummaryDto, type CohesionRequest, type CohesionResponse, type CollectionDto, collections as Collections, type ColumnMappingDto, type CommitFlowNetworkRequest, type CommitRequest, type CommittedForecast, communities as Communities, type CommunityDetectionConfigDto, type CommunityDetectionStatsDto, type CommunityDto, type CommunityMatchDto, type CommunityReportDto, type CommunityReportSummaryDto, type CommunitySearchModeDto, type CommunitySearchStatsDto, type CommunityStatsDto, type CompareDocumentsRequest, type CompareModelDto, type ComparisonOp, type CompetitorForecast, compliance as Compliance, complianceMarkings as ComplianceMarkings, type ComponentDto, type ComponentHealthDto, type ComputeGlbResponse, type ComputeLubResponse, type ConceptMatchDto, type CondRequest, type CondResponse, type ConditionalBranchDto, type ConditionalIndependenceRequest, type ConditionalIndependenceResponse, type ConfirmResponse, type ConflictResolution, type ConfluenceConflictDto, type ConfluenceDto, conformal as Conformal, type ConformalCalibrateRequest, type ConformalCalibrateResponse, type ConformalPredictRequest, type ConformalPredictResponse, type ConformalPrediction, conformance as Conformance, type ConformanceCheckResponse, type ConformanceRepairResponse, type ConformanceRequest, type ConformityArticleDto, type ConformityResponse, type ConnectorInstance, type ConnectorType, connectors as Connectors, type ConstrainedGenerateRequest, type ConstrainedGenerateResponse, type ConstrainedPlainVar, Constraint, type ConstraintCheckDto, type ConstraintDto, type ConstraintGraphRequest, type ConstraintGraphResponse, type ConstraintGraphStats, type ConstraintInputDto, type ConstraintOperator, type ConstraintSense, type ConstraintSessionStatus, ConstraintViolationError, constraints as Constraints, type ContainmentVerificationDto, type ContinuousMediationObservationDto, type ContinuousObservationDto, type ContinuousTreatmentObservationDto, type ContradictionDto, type ContradictionResolutionDto, control as Control, type ControlNafRequest, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTrainingConfigDto, type ConversationTurnDto, type ConversationTurnsResponse, type CoordinatedResourceSet, type CopyModeDto, type CopyTermRequest, type CoreGroup, corpus as Corpus, type CorpusBridgeEdge, type CorpusBridgesRequest, type CorpusBridgesResponse, type CorpusCommunitiesRequest, type CorpusCommunitiesResponse, type CorpusCommunity, type CorpusCommunityDocumentShare, type CorpusCrossCuttingItem, type CorpusCrossCuttingItemKind, type CorpusCrossCuttingKind, type CorpusCrossCuttingRequest, type CorpusCrossCuttingResponse, type CorpusDocumentNode, type CorpusEntityRef, type CorpusScope, type CorpusSharedEntity, type CorpusTreemapRow, type CorrectEntityRequest, type CorrectionRecordDto, type CorrelationRequest, type CorrelationResponse, type CosineShape, type CountAuditEntriesResponse, type CounterfactualRequest, type CounterfactualResponse, type CounterfactualTraceDto, type CoverageCertificate, type CreateAgentRequest, type CreateAgentResponse, type CreateChildNamespaceRequest, type CreateCognitiveSortRequest, type CreateCognitiveSortResponse, type CreateCollectionRequest, type CreateConstraintSessionRequest, type CreateConstraintSessionResponse, type CreateCurriedFunctionRequest, type CreateExecutionSessionRequest, type CreateFlowNetworkRequest, type CreateGoalRequest, type CreateGoalResponse, type CreateModuleRequest, type CreateModuleResponse, type CreateOversightSessionRequest, type CreateOversightSessionResponse, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateRootNamespaceRequest, type CreateRuleStoreRequest, type CreateScenarioRequest, type CreateScenarioResponse, type CreateSnapshotRequest, type CreateSortRequest, type CreateSpaceRequest, type CreateStoreTermRequest, type CreateSubscriptionRequest, type CreateSubscriptionResponse, type CreateTenantRequest, type CreateTenantResponse, type CreateTermByNameRequest, type CreateTermInCollectionRequest, type CreateTermInput, type CreateTermInputWithPlainFeatures, type CreateTermRequest, type CreateTermStoreRequest, type CreateVariableRequest, type CrossSectionForecast, type CtlCounterExample, type CtlFormula, type CuriosityTargetDto, type CurriedFunctionResponse, type CurryingContextResponse, type CutRequest, type CutResponse, type CycleDto, type CycleOutcomeDto, type CycleOutcomeSummaryDto, type CyclicGaussianShape, dl as DL, type DSeparatedRequest, type DSeparatedResponse, type DataGroup, type DataMixingStatsDto, type DataPointDto, type DatasetStatisticsDto, type DateTimeValue, type DecisionAuditRequest, type DecisionAuditResponse, type DeclareLatentVariableRequest, type DeclareLatentVariableResponse, type DecodeGlbResponse, type DeepCopyRequest, type DegreeDistributionDto, type DeleteAgentResponse, type DeleteGoalResponse, type DeletePlanRequest, type DeletePlanResponse, type DeleteSnapshotResponse, type DeleteSortResponse, type DeleteSortRulesDisposition, type DeleteSortTermsDisposition, type DeleteSpeakerRequest, type DeleteTenantResponse, type DeleteTermReport, type DeliveryStatusDto, demo as Demo, type DemoSeedRequest, type DemoSeedResponse, type DensityRatioDiagnosticDto, type DependentInfoDto, type DeprecateSortRequest, type DereferenceRequest, type DereferenceResponse, type DerivationSummaryDto, type DerivedInferenceRequest, type DerivedInferenceResponse, type DerivedInferenceResultDto, type DetectCommunitiesRequest, type DetectCommunitiesResponse, type DetectMissingAttributesRequest, type DiDValidationRequest, type DiDValidationResponse, type DiagnosticDto, type DiagnosticsResponse, type DifferentiableFcRequest, type DifferentiableFcResponse, type DiscoverCausalRequest, type DiscoverCausalResponse, type DiscoverEffectsRequest, type DiscoverEffectsResponse, type DiscoverEmlRequest, type DiscoverEmlResponse, type DiscoverSchemaRequest, type DiscoverSchemaResponse, type DiscoverableTypeDto, type DiscoveredFeatureDto, type DiscoveredRelationDto, type DiscoveredSortDto, type DiscoveredSourceRelationDto, discovery as Discovery, type DiscoveryConfigDto, type DiscoveryProofNodeDto, type DiscoveryProofStatsDto, type DiscoveryProofTreeDto, type DiscoveryStateDto, type DiscoveryStatusResponse, type DiscoveryStrategy, type DisentailmentRequest, type DisentailmentResponse, type DiversityAnalysisDto, type DlSatisfiableRequest, type DlSatisfiableResponse, type DlSubsumesRequest, type DlSubsumesResponse, type DmlAteRequest, type DocumentAnalysisReport, type DocumentBatchItem, type DocumentBatchResultDto, documentCheck as DocumentCheck, type DocumentExtractedEntity, type DocumentGraph, type DocumentGraphCommunity, type DocumentGraphEdge, type DocumentGraphNode, type DocumentGraphQuery, type DocumentInput, type DocumentMetadataDto, type DocumentParseStatsDto, type DocumentParser, type DocumentProgressDto, type DocumentProofStep, type DocumentQaPair, type DocumentRecord, type DocumentResult, type DocumentRuleResult, type DocumentRuleSeverity, type DocumentRuleStatus, type DocumentSource, type DocumentStatsDto, type DocumentStatus, type DocumentSummary, type DocumentType, type DocumentVersionsResponse, documents as Documents, type DomainValue, type DoseResponseRequest, type DoseResponseResponse, type DraftFunctionRequest, type DraftFunctionResponse, type DraftRulesRequest, type DraftRulesResponse, type DriveDeficitDto, type DriveDto, type DynamicAddSortRequest, type DynamicAddSortResponse, type DynamicDiscoveryRequest, type DynamicDiscoveryResponse, type DynamicQueryClauseDto, type DynamicQueryGroupDto, type DynamicQueryRequest, type DynamicQueryResponse, type DynamicQueryResultDto, type E2ETrainingRequest, type E2ETrainingResponse, type EdgeCapacityUpdate, type EdgeClass, type EdgeClassification, type EdgeFlow, type EdgeSpec, type EdgeTypeDto, type EffectDto$1 as EffectDto, type EffectPredictionDto, type EmbeddingRankRequest, type EmbeddingRankResponse, type EmbeddingVerificationResponse, embeddings as Embeddings, type EmlSample, type EncodeClipRequest, type EncodeClipResponse, type EncoderConfigOverrides, type EndSchedulingResponse, type EnforcementStrategy, type EnrichedHealthResponse, type EnrollSpeakerRequest, type EnrollSpeakerResponse, type EnrollVoiceRequest, type EntailmentRequest, type EntailmentResponse, type EntityDto, type EntityVerificationDetailDto, type EpisodeDto, type EpisodeOutcomeDto, type EpisodeStatsResponse, type EqLiteralDto, type EqualityAtomDto, type EquivalenceClass, type EquivalenceClassDto, type ErrorResponse$1 as ErrorResponse, type EvalBuiltinRequest, type EvalBuiltinResponse, type EvalFunctionInfoDto, type EvaluateFunctionRequest, type EvaluateFunctionResponse, type EvaluatePatternRequest, type EvaluatePatternResponse, type EvaluatedValueDto, type EvaluationResult, type EvidenceAssessmentRequest, type EvidenceAssessmentResponse, type EvidenceDerivationConfigDto, type EvidenceItemDto, type EvidenceItemSummaryDto, type EvidenceSourceDto, execution as Execution, type ExecutionGoalDto, type ExecutionSessionResponse, type ExecutionSessionStatsResponse, type ExecutionValueDto, type ExogenousNoiseDto, type ExplorationCompleteResponse, type ExplorationProgress, type ExplorationQuestion, type ExplorationStatusResponse, type ExportJsonlResponse, type ExpressionDto, type ExtendedAgentStateDto, type ExternalActionSummaryDto, type ExternalMatchDto, type ExternalRefValue, extract as Extract, type ExtractEntitiesRequest, type ExtractEntitiesResponse, type ExtractImageRequest, type ExtractImageResponse, type ExtractedEntityDto, type ExtractionPredictionDto, type ExtractionStatsDto, type ExtractionStrategy, type ExtractionStrategyAdaptive, type ExtractionStrategyHybrid, type ExtractionStrategyLlm, type ExtractionStrategyLocalNer, type ExtractionStrategySchemaGuided, type FactConfidenceEntry, type FactoryResetResponse, type FailedReviewDto, type FdDomainStateDto, feasibility as Feasibility, type FeatureBindingDto, type FeatureChangeDto, type FeatureConfigDto, type FeatureDescriptorDto, type FeatureFilterDto, type FeatureInputConstrainedVariable, type FeatureInputInlineTerm, type FeatureInputInlineTermByName, type FeatureInputSortRef, type FeatureInputTermRef, type FeatureInputValueDto, type FeatureInputVariable, type FeatureMismatchDto, type FeaturePair, type FeatureRequirementDto, type FeatureTargetDto, type FeatureTypeDto, type FeatureValueDto, type FinalizeOversightSessionRequest, type FindBySortRequest, type FindPlansRequest, type FindPlansResponse, type FindRulesRequest, type FindRulesResponse, type FindSimilarRequest, type FindallRequest, type FindallResponse, type FindingKind, type FindingSeverity, type FixSuggestionDto, Flow, type FlowAlgorithm, type FlowProblem as FlowBuilderProblem, type FlowEdgeInput, type FlowEdgeOptions, type FlowNetworkResponse, flowNetworks as FlowNetworks, type FlowNode, type FlowProblemInputBase, type FocusEntryDto, type ForallRequest, type ForallResponse, ForbiddenError, forecast as Forecast, type ForecastAbstention, type ForecastBody, type ForecastCertificate, type ForecastCoveringSet, type ForecastDomain, type ForecastDomainsResponse, type ForecastEntityInput, type ForecastRequest, type ForecastResponse, type FormalJudgeRefinementResponse, type FormalJudgeRequest, type FormalJudgeResponse, type FormalVerdictDto, type ForwardChainRequest, type ForwardChainResponse, type FoundryReviewItemDto, type FrameSummary, type FrequencyEstimate, type FrequencyRequest, type FrequencyResponse, type FrontDoorObservationDto, type FrontDoorRequest, type FrontDoorResponse, type FunctionBodyDto, type FunctionCaller, type FunctionCallerKind, type FunctionCallersDisposition, type FunctionClauseDto, type FunctionDefinitionSignature, type FunctionDraftDto, type FunctionGuardDto, type FunctionKindDto, type FunctionNotReplaceableDto, type FunctionSummaryDto, type FunctionType, type FunctionTypeListResponse, type FunctionValueDto, type FunctionWithdrawalReport, functions as Functions, fuzzy as Fuzzy, type FuzzyConceptLevel, type FuzzyMergeRequest, type FuzzyMergeResponse, type FuzzyNumberValue, type FuzzyProveRequest, type FuzzyProveResponse, type FuzzyScalarValue, type FuzzySearchResultItem, type FuzzySearchTopKRequest, type FuzzySearchTopKResponse, FuzzyShape, type FuzzyShapeDto, type FuzzySubsumptionRequest, type FuzzySubsumptionResponse, type FuzzyUnifyRequest, type FuzzyUnifyResponse, type GESResultDto, type GFlowNetSampleRequest, type GFlowNetSampleResponse, type GFlowNetTrainResponse, type GateRequest, type GateResponse, type GaussianProductShape, type GaussianShape, type GenMode, type GeneralConstraintDto, type GenerateDocumentRequest, type GenerateDocumentResponse, type GenerateNegativesRequest, type GenerateNegativesResponse, type GenerateOntologyRequest, type GenerateOntologyResponse, type GenerateSyntheticDataRequest, type GenerateSyntheticDataResponse, generation as Generation, type GenerationPromptRequest, type GenerationPromptResponse, type GenerationProvenanceDto, type GenerationReportDto, type GenerationVerificationDto, type GenericModelRequest, Geometry, type GeometryDto, type GeometryValue, type GetAgentDrivesRequest, type GetAgentStateRequest, type GetAgentStateResponse, type GetBindingsRequest, type GetCausalModelResponse, type GetEpisodeStatsRequest, type GetEquivalenceClassesResponse, type GetExtendedAgentStateRequest, type GetExtendedAgentStateResponse, type GetFactsResponse, type GetFunctionResponse, type GetFuzzySubsumptionRequest, type GetFuzzySubsumptionResponse, type GetInboxRequest, type GetInboxResponse, type GetMembershipsRequest, type GetMembershipsResponse, type GetPreorderDegreeRequest, type GetPreorderDegreeResponse, type GetResiduationsRequest, type GetResiduationsResponse, type GetRulesResponse, type GetScenarioResponse, type GetSortSimilarityRequest, type GetSortSimilarityResponse, type GetStoreTermRequest, type GetStoreTermResponse, type GlbLubComputationTrace, type GlbLubOperation, type GlbLubTraceRequest, type GlbLubTraceStep, type GlbRequest, type GlbResponse, type GlobalAssignRequest, type GlobalAssignResponse, type GlobalGetRequest, type GlobalGetResponse, type GlobalIncrementRequest, type GlobalIncrementResponse, type GoalDto, type GoalEvaluationResultDto, type GoalResiduationRequest, type GoalResiduationResponse, type GoalStackEntryDto, type GoalStackResponse, type GoalStatusUpdate, type GoalSummaryDto, type GraphEdgeDto, type GraphExportFormat, type GraphMetadataDto, type GraphNodeDto, type GraphSparqlQueryRequest, type GraphSparqlResults, type GroundTruthEntry, type GroundTruthStatus, type GroundedGenerateRequest, type GroundedGenerateResponse, type GroundedSchemaResponse, type GroundingStatsDto, type GroupedRankForecast, type GuardOp, guardrail as Guardrail, type GuardrailReport, type GuardrailRequest, type GuardrailSummary, health as Health, type HeavyHitterItem, type HeavyHittersRequest, type HeavyHittersResponse, type HipaaIdentifier, homoiconic as Homoiconic, type HomoiconicSubstitutionDto, type HorizonDto, type HtnMethodDto, type HyperedgeDto, type HyperedgeTypeDto, type HypergraphRequest, type HypergraphResponse, type HypergraphStats, ilp as ILP, type IdentificationRefDto, type IdentifyEffectRequest, type IdentifyEffectResponse, type ImageExtractedEntityDto, type ImageExtractedRelationDto, imageExtraction as ImageExtraction, type ImageExtractionStatsDto, type ImageSuggestedSortDto, type ImpasseDto, type Implication, type ImpliesRequest, type ImpliesResponse, type ImportFoundryRequest, type ImportFoundryResponse, type ImportModuleRequest, type ImportModuleResponse, type ImportOwlRequest, type ImportOwlResponse, type InboxMessageDto, type IncompleteDocumentDto, type InfeasibleResult, inference as Inference, type InfluenceDto, type IngestDocumentBatchRequest, type IngestDocumentBatchResponse, type IngestDocumentRequest, type IngestDocumentResponse, type IngestFromSourceRequest, type IngestFromSourceResponse, type IngestKifRequest, type IngestKifResponse, type IngestMarkdownBatchRequest, type IngestMarkdownRequest, type IngestMarkdownResponse, type IngestPaperRequest, type IngestPaperResponse, type IngestRdfRequest, type IngestRdfResponse, type IngestStepRequest, ingestion as Ingestion, type IngestionConfigDto, IngestionFailedError, type IngestionPollOptions, IngestionSession, type IngestionSessionResponse, type IngestionSessionStatusDto, type IngestionStatsDto, type IngestionSyncOptions, type InlineDocument, type InstallList, type InstallPluginRequest, type InstallPluginResponse, type InstallState, type InstallSummary, type IntegerValue, type IntegratedCycleOutcomeDto, type IntegratedEngineConfigDto, type IntegrationGroupDto, type IntegrityResponse, type IntentionDto, type InteractionGraphDto, type Interceptor, type InterfaceType, type InterfaceTypeListResponse, InternalServerError, type InterventionDto, type InterventionObservationRequest, type InterventionObservationResponse, type InterventionRecommendationDto, type InterventionRequest, type InterventionResponse, type InvokeActionRequest, type InvokeActionResponse, type IterationMetricDto, type JsonValue$1 as JsonValue, type JudgeConfigDto, type KAnonymityResult, type KAnonymityViolation, type KBOptimizationConfig, type KBOptimizationResult, type KBResourceConstraint, type KBVariableSpec, type KbChangeDto, type KbChangeType, type KeyProvenanceDto, type KnowledgeGapDto, type KripkeState, type KripkeTransition, LP, ltn as LTN, type LatticeStats, type LatticeVisualizationRequest, type LatticeVisualizationResponse, type LayerResultDto, type LayerResultSummaryDto, type LayoutAlgorithmDto, type LayoutDirectionDto, type LayoutHintsDto, type LayoutModeDto, type LayoutSlotDto, type LayoutSurfaceDto, type LazyEvalRequest, type LazyEvalResponse, type LearnFromCorrectionRequest, type LearnFromCorrectionResponse, type LearnPatternConfigDto, type LearnPatternRequest, type LearnPatternResponse, type LearnSortSimilaritiesRequest, type LearnSortSimilaritiesResponse, type LearnedPatternDto, type LearnedSimilarityDto, type LearnedSimilarityListResponse, type LearnedSimilarityProvenanceDto, type LearnedSimilarityStatusDto, type LedgerInfoDto, type LinExpr, type LinTerm, type LinearConstraint$1 as LinearConstraint, type LinearExpression, type LinearProgramDefinition, type LinkPredictionRequest, type LinkPredictionResponse, type LinkType, type LinkTypeListResponse, type ListActionReviewsOptions, type ListActionReviewsResponse, type ListAgentsResponse, type ListAuditEntriesQuery, type ListAuditEntriesResponse, type ListAuditOptions, type ListBindingsResponse, type ListCatalogParams, type ListConversationsResponse, type ListDocumentsQuery, type ListDocumentsResponse, type ListEnginesResponse, type ListEvalFunctionsRequest, type ListEvalFunctionsResponse, type ListExternalActionsResponse, type ListFunctionsResponse, type ListGoalsResponse, type ListIncompleteDocumentsResponse, type ListIngestionSessionsResponse, type ListInstallsParams, type ListLevelsResponse, type ListPatternsResponse, type ListPendingInvocationsResponse, type ListPendingReviewsOptions, type ListPreferencesResponse, type ListResearchSessionsResponse, type ListScenariosResponse, type ListSnapshotsResponse, type ListSortsQuery, type ListSourceTypesResponse, type ListSourcesResponse, type ListSpeakersResponse, type ListSubscriptionsResponse, type ListSymbolsRequest, type ListSymbolsResponse, type ListTablesResponse, type ListTenantsResponse, type ListTermsQuery, type ListValue, type ListVoicesResponse, type Lit, type LiteralFeatureValue, type LiteralInputDto, type LogOddsAntecedentContributionDto, type LogOddsScoreDecompositionDto, type LogOddsWitnessDto, type LtnAggregator, type LtnAggregatorKind, type LtnFeatureText, type LtnInstance, type LtnLearnedCertainty, type LtnPredicateExample, type LtnPredicateFit, type LtnPredicateTraining, type LtnQueryKind, type LtnQueryRequest, type LtnQueryResponse, type LtnRefuteRequest, type LtnRefuteResponse, type LtnRule, type LtnTrainRequest, type LtnTrainResponse, type LtnWitnessEntry, type LubRequest, type LubResponse, type MarkChoicePointRequest, type MarkMessagesReadRequest, type MarkMessagesReadResponse, type MarkPendingRequest, type MarkPendingResponse, type MarkRuleStoreRequest, type MarkRuleStoreResponse, type MarkTermStoreRequest, type MarkTermStoreResponse, type MarkdownDocumentDto, marketplace as Marketplace, type MarketplaceScope, type MatchedEntityDto$1 as MatchedEntityDto, type MaterializationSummaryDto, type MaterializeScenarioRequest, type MaterializeScenarioResponse, type MathFunctionRequest, type MathFunctionType, type MaxFlowInput, type MaxFlowVars, type MeasurementRole, type MeasurementUnitDto, type MeasurementValue, type MediationDmlRequest, type MediationEffectDto, type MediationObservationDto, type MediationRequest, type MediationResponse, type MeetPreservationDto, type MembershipDto, type MembershipRequest, type MembershipResponse, type MembershipResult, type MergeEntityRequest, type MetaSortsResponse, type MinCostMaxFlowInput, type MinCostMaxFlowVars, type MinCutInput, type MinCutReport, type MinCutVars, type MissingInfoDto, type ModifyActionRequest, type ModularArithRequest, type ModularOperationType, type MonadicFactDto, type MonadicFixpointRequest, type MonadicFixpointResponse, type MotivationStateDto, type MoveDto, type MultiMediationObservationDto, type MultiMediationRequest, type NafProveRequest, type NafProveResponse, type NafResponse, type NamespaceDto, type NamespaceListResponse, type NamespaceResponse, namespaces as Namespaces, type NegativeExampleDto, NetworkError, neuroSymbolic as NeuroSymbolic, type NeuroSymbolicStatusResponse, type NlQueryMode, type NlQueryRequest, type NlQueryResponse, type NlQueryResultItem, type NodeScore, type NodeTypeDto, NotFoundError, type NumberFormatDto, type NumberToStringRequest, type NumberValueDto, type NumberedPage, type NumberedPageReader, type OAuthCallbackQuery, type OAuthStartResponse, type ObjectType, type ObjectTypeListResponse, type Objective, type ObjectiveFunction, type ObjectiveSense, type ObservationDto, type ObservationalProbabilitiesDto, type ObserveMultiRequest, type ObserveMultiResponse, type ObservePairRequest, type ObservePairResponse, type ObserveSingleRequest, type ObserveSingleResponse, type OcrConfigDto, type OffsetPage, type OffsetPageReader, ontology as Ontology, ontologyAlignment as OntologyAlignment, ontologyBridge as OntologyBridge, type OntologyClarificationQuestionDto, ontologyExport as OntologyExport, type OntologyExportDocument, type OntologyExportFormat, type OntologyExportOptions, ontologyFacade as OntologyFacade, type OntologyRagRequest, type OntologyRagResponse, type OntologyRagStatsDto, type OpenSpeechSessionRequest, type OpenSpeechSessionResponse, type Operand, operations as Operations, type OptimalResult, type OptimizationDirection, type OptimizationResult, optimize as Optimize, type OrderedCombo, type OrientPairDiagnosticsDto, type OrientPairDirectionDto, type OrientPairFitDto, type OrientPairIndependenceTestRequest, type OrientPairRegressionBasisDto, type OrientPairRegressionRequest, type OrientPairRequest, type OrientPairResponse, type OrientPairVerdictDto, osfDiff as OsfDiff, type OsfDiffReport, type OsfDiffRequest, type OsfDiffResponse, type OsfDiffSelector, type OsfDiffSequenceReport, type OsfDiffSequenceRequest, type OsfDiffSequenceResponse, type OsfDiffTemporalRequest, type OsfSearchRequest, type OsfSearchResponse, type OsfSearchStatsDto, osfql as Osfql, type OsfqlAtomicRefusal, type OsfqlCatalogEntry, type OsfqlCatalogExecution, type OsfqlCatalogUiAffinity, type OsfqlDiagnoseRequest, type OsfqlDiagnoseResponse, type OsfqlDiagnostic, type OsfqlPreviewAffected, type OsfqlPreviewResponse, type OsfqlPreviewSortCount, type OsfqlPreviewStatement, type OsfqlRange, type OsfqlRequest, type OsfqlResponse, type OsfqlTermValue, type OsfqlValue, type OutputFormatDto, type OverlapDiagnosticDto, oversight as Oversight, type OversightAlertDto, type OversightSessionStatusResponse, type PaginateOptions, type PaginationParams, type PaperMetadataDto, type PaperRefDto, type PaperSearchResultDto, type PaperSource, type ParamSpec, type ParsedDocumentMetadataDto, type PartialCorrelationRequest, type PartialCorrelationResponse, type PatchSortFeatureRequest, type PatchSortRequest, type PathRequest, type PathResponse, type PathwaysDto, type PatternDto, type PatternSummaryDto, type PendingActionReviewDto, type PendingInvocationDto, type PendingReviewDto$1 as PendingReviewDto, type PiShapeShape, type PiecewiseLinearShape, type Pin, type PipelineQualityStatsDto, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, type PlanMatchDto, type PluginDependency, type PluginDetail, type PluginManifest, type PluginSummary, type PluginVersion, type Point2DGeometry, type PolicyRowDto, type PolicyRuleDto, type PolicyValueRequest, type PolicyValueResponse, type PolygonGeometry, type PositionalArgumentDto, type PredictEffectRequest, type PredictEffectResponse, type PredictFromDiscoveryRequest, type PredictFromDiscoveryResponse, type PredictPreferencesRequest, type PredictPreferencesResponse, type PredictionEntry, type PredictionErrorDto, type PredictionInterval, type PredictionSnapshot, type Preference, type PreferenceDto, type PreferencePrediction, preferences as Preferences, type PrerequisiteInfoDto, type ProbabilityBoundDto, type ProofDto, proofEngine as ProofEngine, type ProofEngineCreateTermResponse, type ProofExportFormat, type ProofExportRequest, type ProofExportResponse, type ProofExportResult, type ProofKind, type ProofLiteralDto, type ProofNodeDto, type ProofStatisticsDto, type ProofTraceDto, type ProofTraceNodeDto, type Property, propertyGraph as PropertyGraph, type PropertyGraphErrorResponse, type PropertyGraphExecuteResponse, type PropertyGraphQueryRequest, type PropertyGraphTranslateResponse, type PropertyGraphValue, type ProvenanceStepDto, type ProvenanceTagDto, type ProvideFeedbackRequest, type ProvideFeedbackResponse, type PsiTermDto, type PsiTermInput, type PsiTermInputById, type PsiTermInputByName, type PsiTermValue, type PublishPluginRequest, type PublishPluginResponse, type PushGoalRequest, type PushGoalResponse, type QuasiIdentifier, query as Query, type QueryResultDto, type QueryTerm, rag as RAG, type RankedInstrument, RateLimitError, type RateLimitInfo, type RawGenerateRequest, type RawGenerateResponse, type RdfFormatDto, type ReExtractRequest, type ReachableDto, type ReachedEdgeDto, type ReachedStateDto, type ReadableTermDto, type ReadableTermsResponse, type RealValue, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type ReasoningStageDto, type ReasoningTraceDto, type RecallEpisodesRequest, type RecallEpisodesResponse, type RecalledEpisodeDto, type RecordEpisodeRequest, type RecordEpisodeResponse, type RecordSafeHarborStatus, type RecordSelectionRequest, type RecordSelectionResponse, type RecordTurnRequest, type RecordTurnResponse, type ReferenceDesignator, type ReferenceValue, type ReferencedTermSummary, type ReflectionQueryRequest, type ReflectionQueryResponse, type RefutationCheckDto, type RefutationObservationDto, type RefuteEstimateRequest, type RefuteEstimateResponse, type RefuteRequest, type RefuteResponse, type RegisterExternalActionRequest, type RegisterExternalActionResponse, type RegisterFunctionRequest, type RegisterFunctionResponse, type RegisterSourceRequest, type RegisterSourceResponse, type RegressionBasis, type RejectActionRequest, type RejectEntityRequest, type RejectLearnedSimilarityRequest, type RejectLearnedSimilarityResponse, type RelOp, type RelOpDto, type RelatedInfoDto, type RelationTypeDto, type RelationalArithRequest, type ReleaseResiduationsRequest, type ReleaseResiduationsResponse, type RemoveSortFeatureOptions, type ReplaceFunctionResponse, type ReplaceRuleResponse, type ReportVerificationDto, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchCycleResultDto, type ResearchFindingDto, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, type ResearchSessionStatusDto, type ResearchSessionSummaryDto, type ResearchStatisticsDto, type ResidualWitnessDto, type ResiduateGoalRequest, type ResiduateGoalResponse, type ResiduatedEntryDto, type ResiduatedFeatureDto, type ResiduatedTermDto, type ResiduationDetailDto, type ResiduationDto, type ResiduationGoalDto, type ResiduationKind, type ResiduationRequest, type ResiduationResponse, type ResiduationStateDto, type ResiduationStateFilter, type ResiduationStateRequest, type ResiduationStateResponse, type ResiduationStats, type ResolutionStrategyDto, type ResolveSymbolRequest, type ResolveSymbolResponse, type ResolvedCoreferenceDto, type ResourceCoordinationRequest, type ResourceCoordinationResponse, type ResourceSpec, type ResumeDocumentIngestionRequest, type ResumeDocumentIngestionResponse, type ResumptionOptionDto, type RetentionDto, type RetractRuleRequest, type RetractRuleResponse, type RetrievalStatsDto, type ReviewCandidateMatchDto, type ReviewReason, reviews as Reviews, reward as Reward, type RewardObjective, type RewardScoreRequest, type RewardScoreResponse, type RiskTier, type RlPolicyConfigDto, type RlPolicyWeightsDto, type RlPolicyWeightsUploadResponse, type RlTrainRequest, type RlTrainResponse, type RootCauseAnalysisRequest, type RootCauseAnalysisResponse, type RootCauseDto, type RootCauseWithProofResponse, row as Row, type RowIntegrateRequest, type RowIntegrateResponse, type RowMatchDto, type RowSearchRequest, type RowSearchResponse, type RowSimilarityRequest, type RowSimilarityResponse, type RowTypeDto, type RowUnifyRequest, type RowUnifyResponse, type RuleAggregatorDto, type RuleAggregatorOp, type RuleBaseCertificateDto, type RuleCertificationDelta, type RuleClauseDto, type RuleConstraintDto, type RuleDerivationsDisposition, type RuleDraftClarificationQuestionDto, type RuleDraftDto, type RuleDto, type RuleEntryDto, type RuleNotWithdrawable, type RuleOrigin, type RuleStoreResponse, type RuleTermDraftDto, type RuleUtilityDto, type RuleWithdrawalReport, type RunAgentRequest, type RunCycleRequest, type RunCycleResponse, type RunIntegratedCycleRequest, type RunIntegratedCycleResponse, SDK_VERSION, type SShapeShape, type SafeHarborSummary, type SafetyModelInfoDto, type SampledHypothesisDto, sat as Sat, type SatLiteralDto, type SatSatisfiableResult, type SatSolveRequest, type SatSolveResponse, type SatSolverStatsDto, type SatUnknownResult, type SatUnsatisfiableResult, type SatVerdict, type SaveWeightsResponse, type ScenarioSummaryDto, scenarios as Scenarios, scheduling as Scheduling, type SchedulingDeltaResponse, type SchedulingFeasibilityRequest, type SchedulingFeasibilityResponse, type SchedulingOptimizeRequest, type SchedulingOptimizeResponse, type SchedulingSessionResponse, type SchedulingStatus, type SchemaExcerptDto, type ScmCounterfactualRequest, type ScmCounterfactualResponse, type ScoreTermsRequest, type ScoreTermsResponse, type ScoredTerm, type SearchCatalogRequest, type SearchCatalogResponse, type SearchCommunitiesRequest, type SearchCommunitiesResponse, type SearchModeDto, type SearchPapersRequest, type SearchPapersResponse, type SearchSortsBy, type SearchSortsMatch, type SearchSortsRequest, type SearchSortsResponse, type SearchStatsDto, type SearchStrategyDto, type SendMessageRequest, type SendMessageResponse, type SensitivityDto, type SeriesEpochUnit, type SeriesMissingPolicy, type SeriesOperator, type SeriesTimeSource, type SeriesValueSource, type SeriesWindowSpec, type SessionGraphDto, type SessionProgressResponse, type SessionStatsResponse, type SetActionReviewConfigRequest, type SetActionReviewConfigResponse, type SetFeatureRequest, type SetFeatureResponse, type SetFuzzySubsumptionRequest, type SetFuzzySubsumptionResponse, type SetGoalStatusRequest, type SetGoalStatusResponse, type SetPreferenceRequest, type SetSortSimilarityRequest, type SetSortSimilarityResponse, type SetValue, type ShiftDemand, type ShiftEffectRequest, type ShiftEffectResponse, type SigmoidDifferenceShape, type SigmoidProductShape, type SigmoidShape, type SimilarityEntryDto, type SimilarityMatch, type SimilaritySearchResponse, type SimpleTgdDto, type SingleCopyRequest, type SketchDimensions, smt as Smt, type SmtCheckRequest, type SmtCheckResponse, type SmtFunctionApplicationDto, type SmtSatResult, type SmtUnknownResult, type SmtUnsatResult, type SmtVerdict, type SnapshotFilter, type SnapshotResponse, snapshots as Snapshots, type SoftUnifyRequest, type SoftUnifyResponse, type SolutionDto, type SolutionStatus, type SolveConstraintRequest, type SolveConstraintResponse, type SolveFlowNetworkRequest, type SolveFlowNetworkResponse, type SolveOptions, type SolveProblemRequest, type SolveProblemResponse, solver as Solver, type SolverHealthResponse, type SolverHint, type SortBoxRequest, type SortBoxResponse, SortBuilder, type SortCalibrationDto, type SortCompareOperator, type SortCompareRequest, type SortCompareResponse, type SortDiscoveryRequest, type SortDiscoveryResponse, type SortDto, type SortFeatureEditResponse, type SortIdValue, type SortIndexStatusResponse, type SortInfoDto, type SortListResponse, type SortOriginDto, type SortRecommendation, type SortReferenceKind, type SortReferencingRuleDto, type SortResponse, type SortSimilarityResponse, type SortStatusDto, type SortSuggestionDto, type SortSummaryDto, sorts as Sorts, type SortsSchemaQuery, type SourceDetailResponse, type SourceExcerptDto$1 as SourceExcerptDto, type SourceSummaryDto, type SourceTypeDto, type SourceWriteMode, sources as Sources, type SpaceConstraintDto, type SpaceResponse, type SpaceSearchRequest, type SpaceSearchResponse, type SpaceSolutionDto, type SpaceStatusDto, spaces as Spaces, sparql as Sparql, type SparqlAskResults, type SparqlBindingSet, type SparqlEntailmentRegime, type SparqlOrderByKey, type SparqlOsfqlLeaf, type SparqlPlanNode, type SparqlQueryForm, type SparqlQueryRequest, type SparqlQueryResults, type SparqlRdfTerm, type SparqlSelectResults, type SparqlTranslation, type SparqlTripleTermValue, type SparqlUpdateRequest, type SparqlUpdateTranslation, type SpeakerProfile, speakers as Speakers, type SpecificityDto, speech as Speech, type SpeechEngine, type SpikeShape, type StartExplorationRequest, type StartExplorationResponse, type StartIngestionSessionRequest, statistical as Statistical, type StatisticalSuccessResponse, type StepLogEntryDto, type StepVerificationResponse, type StorePlanRequest, type StorePlanResponse, streaming as Streaming, type StringCompareOperator, type StringComparePredicateRequest, type StringCompareRequest, type StringConcatRequest, type StringLengthRequest, type StringOpParams, type StringOpRequest, type StringOperationType, type StringValue, type StructuralAssignmentDto, type StructuredIngestionStatsDto, type SubscribeToKbRequest, type SubscribeToKbResponse, type SubscriptionDto, type SubscriptionEventKind, subscriptions as Subscriptions, type SubstringRequest, type SummaryResponse, type SuspendedQueryDto, type SymbolDto, type SymbolKindDto, type SymbolicResultDto, type SynthesizeRequest, type SynthesizeResponse, type SynthesizeSpeechRequest, synthetic as Synthetic, type SystemGroup, type TaggedDerivedFact, type TaggedFactDto, type TaggedFcRequest, type TaggedFcResponse, type TaggedFeatureValueDto, type TaggedForwardChainRequest, type TaggedForwardChainResponse, temporal as Temporal, type TemporalModelCheckRequest, type TemporalModelCheckResponse, type TemporalPlanRequest, type TemporalPlanResponse, type TemporalPoint, type TemporalRule, type TemporalSeries, type TemporalSeriesPoint, type TemporalSeriesRequest, type TemporalSeriesResponse, type TemporalSeriesSpec, type TemporalTrendSummary, type TenantInfoDto, type TermBindingDto, type TermDto, type TermEdit, type TermInputArg, type TermInputDesignator, type TermInputDto, type TermInputInline, type TermInputInlineByName, type TermInputRef, type TermListResponse, type TermOrigin, type TermPatternDto, type TermRefFeatureValue, type TermReferencesDisposition, type TermReferrerDto, type TermReferrersResponse, type TermResponse, type TermSetSelector, type TermState, type TermStoreSessionResponse, type TermVersionDto, type TermVersionsResponse, type TerminationDto, terms as Terms, type TestInput, thomas as Thomas, type ThomasPathwaysRequest, type ThomasStudyRequest, type ThomasStudyResponse, TimeoutError, type TokenUsageDto, type ToolCallInfo, type TraceEventDto, type TrailEntryDto, type TrainFromTracesResponse, type TrainingExample, type TrainingExampleDto, type TrainingTriggerResponse, type TrajectoryStepDto, type TranscribeSpeechRequest, type TranscribeSpeechResponse, type TranslateRdfRequest, type TranslateRdfResponse, type TranslateRequest, type TranslateResponse, type TranslatedRdfTermDto, translation as Translation, type TranspileRequest, type TranspileResponse, type TrapezoidalShape, type TriangularShape, type TriggerDependencyRequest, type TriggerDependencyResponse, type TurnDto, type TypedConstraint, ui as UI, type UIActionDto, type UIActionRequest, type UIActionResponse, type UIAssemblyStatsDto, type UICatalogEntry, type UICatalogResponse, type UICustomizationDto$1 as UICustomizationDto, type UIDescribeRequest, type UIDescribeResponse, type UIDescriptorDto, type UIGenerateRequest, type UIGenerateResponse, type UiSort, type UnaryOperatorDto, type UncertainEdgeDto, type UndoRequest, type UndoResponse, type UndoRuleStoreRequest, type UndoRuleStoreResponse, type UnifiableQueryRequest, type UnificationQueryResponse, type UnifyTermsRequest, type UnifyTermsResponse, type UninstantiatedValue, type UpdateCollectionRequest, type UpdateMetadataRequest, type UpdatePlanStatsRequest, type UpdatePlanStatsResponse, type UpdateReviewStatusRequest, type UpdateScenarioRequest, type UpdateScenarioResponse, type UpdateTenantNameRequest, type UpdateTenantNameResponse, type UpdateTermRequest, type UpdateVisibilityRequest, type UpgradeInstallRequest, utilities as Utilities, type ValidateTermRequest, type ValidatedTermResponse, type ValidatedUnifyRequest, type ValidatedUnifyResponse, ValidationError, type ValidationReportDto, type ValidationRuleDto, type ValidationTypeDto, Value, type ValueDto, type ValuePatternDto, values as Values, type VarKind, type VariableBounds, type VariableClassification, type VariableDto, type VariableFeasibilityDto, type VariableFeatureValue, type VariableSpec, type VerbalizationResultDto, type VerbalizeTermRequest, type VerbalizeTermResponse, verification as Verification, type VerificationStepDto, type VerifyClaimRequest, type VerifyClaimResponse, type VerifyFaithfulnessRequest, type VerifyFaithfulnessResponse, type VerifyResponse, type VerifyRoundTripRequest, type VerifyRoundTripResponse, type VerifyScenarioRequest, type VerifyScenarioResponse, type VersionDiffDto, type ViolationCountsDto, type ViolationDto, type VisibilityDto, vision as Vision, visualization as Visualization, type VisualizationGraphDto, type VoiceConsent, type VoiceProfile, type WaitingConditionDto, type WaitingConditionType, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WebhookCallbackRequest, type WebhookCallbackResponse, type WeightedFactDto, type WitnessInstantiationDto, type WitnessProofDto, type WorkflowGroup, type WorldModeDto, type YankPluginRequest, type YankPluginResponse, type ZShapeShape, aggregate, allen, bind, collect, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, not, paginateByOffset, paginateByPage, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };