@kortexya/reasoninglayer 1.16.0 → 1.18.0

package/dist/index.d.ts

@@ -109,7 +109,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.16.0";
+declare const SDK_VERSION = "1.18.0";
 /**
  * Authentication mode for the SDK.
  *
@@ -1964,6 +1964,22 @@ interface AuditRecord$1 {
 }
 /** @format uuid */
 type AuditRecordId = string;
+/**
+ * Sortable [`AuditRecord`] field for the paged list read API
+ * ([`crate::ports::audit::AuditPort::list_page`]).
+ *
+ * Wire serialisation is `snake_case` (`timestamp`, `request_path`,
+ * `actor`) via `serde(rename_all)`. Defaults to [`AuditSortField::Timestamp`].
+ */
+type AuditSortField$1 = "timestamp" | "request_path" | "actor";
+/**
+ * Sort direction for the paged list read API
+ * ([`crate::ports::audit::AuditPort::list_page`]).
+ *
+ * Wire serialisation is `lowercase` (`asc`, `desc`). Defaults to
+ * [`AuditSortOrder::Desc`] so the most recent entries surface first.
+ */
+type AuditSortOrder$1 = "desc" | "asc";
 /** One audited assumption */
 interface AuditedAssumptionDto$1 {
     /** The assumption kind audited */
@@ -3244,6 +3260,23 @@ interface CancelDocumentResponse {
     /** Human-readable message describing what happened */
     message: string;
 }
+/**
+ * A candidate entity — a Ψ-term-to-be, its sort named rather than resolved because the
+ * sort may not exist yet (which residuates).
+ */
+interface CandidateEntityDto {
+    /**
+     * Extractor confidence in [0, 1]. Advisory — it does not affect the verdict.
+     * @format double
+     */
+    confidence?: number;
+    /** Extracted features, by name. */
+    features?: Record<string, CandidateValueDto>;
+    /** Batch-local id, used to attach relations to this entity. */
+    local_id: string;
+    /** Sort name this entity claims. */
+    sort: string;
+}
 /** A candidate match for entity deduplication */
 interface CandidateMatchDto$1 {
     /**
@@ -3257,6 +3290,40 @@ interface CandidateMatchDto$1 {
      */
     term_id: string;
 }
+/**
+ * A candidate relation — a feature edge whose endpoint sorts the caller supplies so the
+ * fact is self-contained for certification.
+ */
+interface CandidateRelationDto {
+    /**
+     * Extractor confidence in [0, 1]. Advisory.
+     * @format double
+     */
+    confidence?: number;
+    /** Predicate (feature) name. */
+    predicate: string;
+    /** `local_id` of the source entity. */
+    source: string;
+    /** Sort name of the source endpoint. */
+    source_sort: string;
+    /** `local_id` of the target entity. */
+    target: string;
+    /** Sort name of the target endpoint. */
+    target_sort: string;
+}
+/**
+ * A candidate feature value. `value` absent ⇒ the extractor does not know it, which
+ * residuates rather than refutes.
+ */
+interface CandidateValueDto {
+    /** Surface form of the value, as extracted. Omit for an unknown value. */
+    value?: string | null;
+    /**
+     * Primitive type the extractor believes this value has: `String`, `Integer`,
+     * `Real`, `Boolean`, or `DateTime`. Defaults to `String`.
+     */
+    value_type?: string | null;
+}
 interface CaptureSnapshotRequest$1 {
     /** @format date-time */
     captured_after?: string | null;
@@ -4096,8 +4163,27 @@ interface ClearFactsResponse$1 {
  * the operation succeeded without affecting other tenants.
  */
 interface ClearTenantResponse$1 {
+    /**
+     * Number of SQL ontology bindings deleted for this tenant.
+     *
+     * A binding names the source, table and columns a tenant's data lives in,
+     * so it is tenant data in its own right. It used to survive the wipe,
+     * which is how #124 became visible: the connectors page kept listing
+     * bindings whose sources had just been erased.
+     * @min 0
+     */
+    bindings_deleted?: number;
     /** Whether the cache was invalidated */
     cache_invalidated: boolean;
+    /**
+     * Number of materialized derived facts deleted for this tenant.
+     *
+     * The derived-facts repository has always been able to truncate a tenant;
+     * only the separate admin endpoint ever asked it to, so derived Ψ-terms
+     * outlived the facts they were derived from (#124).
+     * @min 0
+     */
+    derived_facts_deleted?: number;
     /**
      * Number of document fingerprints deleted
      * @min 0
@@ -4122,6 +4208,14 @@ interface ClearTenantResponse$1 {
      * @min 0
      */
     reviews_deleted: number;
+    /**
+     * Total rows deleted across every table in `tables_wiped`.
+     *
+     * Counts the tables that have no named counter above, which is most of
+     * them — the named counters predate #124 and were never the full set.
+     * @min 0
+     */
+    rows_deleted_total?: number;
     /**
      * Number of ingestion sessions deleted
      * @min 0
@@ -4129,6 +4223,20 @@ interface ClearTenantResponse$1 {
     sessions_deleted: number;
     /** Whether the sort hierarchy snapshot was deleted */
     sorts_deleted: boolean;
+    /**
+     * Tenant-scoped tables deliberately left intact, each with its reason.
+     *
+     * Non-empty means this erasure was deliberately partial. Reported so a
+     * retention policy can never again be mistaken for complete erasure.
+     */
+    tables_retained?: RetainedTableDto[];
+    /**
+     * Every table the wipe deleted from, children before parents.
+     *
+     * Derived from the live schema, not from a list in the source, so a table
+     * added by a later migration appears here without a code change.
+     */
+    tables_wiped?: string[];
     /** The tenant whose data was cleared */
     tenant_id: string;
     /**
@@ -4136,6 +4244,16 @@ interface ClearTenantResponse$1 {
      * @min 0
      */
     terms_deleted: number;
+    /**
+     * Number of vector-store points deleted for this tenant.
+     *
+     * Reported to the caller because it is the one count an erasure request
+     * cannot verify any other way: vector payloads carry the embedded text, so
+     * a wipe that left them behind would report every table emptied while the
+     * tenant's data stayed readable and retrievable by similarity.
+     * @min 0
+     */
+    vectors_deleted: number;
 }
 /** Response for clearing all terms for a tenant */
 interface ClearTermsResponse$1 {
@@ -4638,7 +4756,15 @@ interface CompareDocumentsRequestDto {
     document_a_id: string;
     /** @format uuid */
     document_b_id: string;
+    /**
+     * Include the clause section — terms sorted under the tenant's
+     * `document.clause` vocabulary (default true)
+     */
     include_clause_diff?: boolean;
+    /**
+     * Include the entity section — everything outside the tenant's
+     * `document.clause` vocabulary (default true)
+     */
     include_entity_diff?: boolean;
     /** @format double */
     threshold?: number | null;
@@ -5706,6 +5832,18 @@ interface CreateCurriedFunctionRequest$1 {
     /** @format uuid */
     tenant_id: string;
 }
+/** Request body for filing a data subject request. */
+interface CreateDsrRequest {
+    /** Identifier of the data subject filing the request. */
+    data_subject: string;
+    /**
+     * Which right is being exercised (Art. 15-22), as the domain's tagged enum.
+     *
+     * Described to OpenAPI as an opaque object: deriving a schema would force a
+     * utoipa dependency into the domain, which must stay free of them.
+     */
+    request_type: object;
+}
 /** Request to create a new execution session with trail-based backtracking */
 interface CreateExecutionSessionRequest$1 {
     /** Optional name for the session */
@@ -7074,6 +7212,11 @@ interface DisentailmentRequest$1 {
 }
 /** Response from disentailment check. */
 interface DisentailmentResponse$1 {
+    /**
+     * How strongly the supplied facts establish the antecedent, μ ∈ [0,1].
+     * @format double
+     */
+    antecedent_degree: number;
     /**
      * Computation time in milliseconds
      * @format int64
@@ -7081,10 +7224,31 @@ interface DisentailmentResponse$1 {
      */
     computation_time_ms: number;
     /**
-     * Confidence degree
+     * Confidence degree.
+     *
+     * Certainty in the result, which is governed by how strongly the facts
+     * establish the antecedent: with no support the verdict is vacuous. Equal
+     * to `antecedent_degree`, and graded where it was previously a `1.0`/`0.0`
+     * cast of "the antecedent was found".
      * @format double
      */
     confidence: number;
+    /**
+     * How strongly the consequent is established, μ ∈ [0,1] — by the facts, or
+     * by the antecedent it would follow from.
+     * @format double
+     */
+    consequent_degree: number;
+    /**
+     * Graded degree to which the disentailment still holds, μ ∈ [0,1].
+     *
+     * `1 - violation_degree`, where the violation degree is
+     * `min(antecedent_degree, consequent_degree)` — the degree to which the
+     * antecedent forces the consequent it was supposed to exclude. `holds` is
+     * this degree read crisply.
+     * @format double
+     */
+    degree: number;
     /** Whether the disentailment holds (antecedent is false, or consequent is false) */
     holds: boolean;
     /** Whether the disentailment is violated (both antecedent AND consequent hold = conflict) */
@@ -7366,6 +7530,26 @@ interface DocumentDto {
      */
     version: number;
 }
+/**
+ * What a document erasure actually removed.
+ *
+ * Counts are reported rather than a bare 204 because erasure is auditable: a
+ * caller has to be able to show *what* went, and a silent success is
+ * indistinguishable from a cascade that walked nothing.
+ */
+interface DocumentErasureReport {
+    /** Whether the document registry row was removed. */
+    document_deleted: boolean;
+    /** The document that was erased. */
+    document_id: string;
+    /** Whether the fingerprint row (which held the term provenance) was removed. */
+    fingerprint_deleted: boolean;
+    /**
+     * Terms removed via the full per-term cascade.
+     * @min 0
+     */
+    terms_deleted: number;
+}
 /** Per-document knowledge graph response. */
 interface DocumentGraphResponse {
     /** Community id → size (legend data) */
@@ -7892,6 +8076,28 @@ interface DriveDto$1 {
     /** Drive type (curiosity, competence, social, autonomy) */
     drive_type: string;
 }
+/** A request record as returned to callers. */
+interface DsrRecordResponse {
+    /** The data subject this request belongs to. */
+    data_subject: string;
+    /** Statutory deadline (UTC). */
+    deadline: string;
+    /** Request id, stable from submission through closure. */
+    id: string;
+    /**
+     * Whether the stored record still matches its own integrity hash.
+     *
+     * Surfaced rather than merely checked so a caller can tell an intact
+     * record from a tampered one instead of trusting the response.
+     */
+    integrity_verified: boolean;
+    /** Whether the deadline has already passed without closure. */
+    overdue: boolean;
+    /** When the request was received (UTC). */
+    received_at: string;
+    /** Current lifecycle status, serialized from the domain enum. */
+    status: any;
+}
 /** Loss weighting (paper eq. 4) — `data_weight + knowledge_weight = 1.0`. */
 interface DualWeightedLossDto {
     /**
@@ -8309,6 +8515,24 @@ interface EffectPredictionDto$1 {
     /** @format double */
     std_dev: number;
 }
+/** Rank request: one query, and the candidates to score against it. */
+interface EmbeddingRankRequest$1 {
+    /**
+     * Candidate texts. Scored in place — the response is index-aligned with
+     * this list, so the caller can zip it back onto whatever it retrieved.
+     */
+    candidates: string[];
+    /** The text every candidate is scored against. */
+    query: string;
+}
+/** Rank response: one cosine similarity per candidate, in request order. */
+interface EmbeddingRankResponse$1 {
+    /**
+     * Cosine similarity in `[-1.0, 1.0]`, same length and same order as
+     * `candidates`. A candidate with no scoreable text scores `0.0`.
+     */
+    scores: number[];
+}
 /** Response for the embedding verification endpoint. */
 interface EmbeddingVerificationResponse$1 {
     /** Whether box embeddings are available. */
@@ -8433,10 +8657,20 @@ interface EnrollSpeakerRequest$1 {
     /** MIME hint (e.g. `"audio/wav"`) for decoding the sample. */
     audio_mime?: string | null;
     /**
-     * Display name for this speaker. Re-enrolling the same name (case-insensitive)
-     * overwrites the existing profile.
+     * Display name for this speaker. Re-enrolling the same (name, variant)
+     * pair — case-insensitive — overwrites the existing profile.
      */
     name: string;
+    /**
+     * Optional sample label, so one person can hold SEVERAL embeddings
+     * ("15-s read-aloud", "meeting 07-30", "sung sample"). This is the
+     * singing fix: a voice is not one point in embedding space, and TitaNet
+     * is speech-trained, so a sung sample is what makes that artist's other
+     * songs match. Matching needs no changes for this — supplying several
+     * prints that share a name already resolves each cluster to the best
+     * cosine overall.
+     */
+    variant?: string | null;
 }
 /** Response from enrolling a speaker voiceprint. */
 interface EnrollSpeakerResponse$1 {
@@ -8457,6 +8691,8 @@ interface EnrollSpeakerResponse$1 {
      * @format double
      */
     sample_secs: number;
+    /** Sample label, when one was supplied. */
+    variant?: string | null;
 }
 /** Request to enroll (or re-enroll) a cloned voice. */
 interface EnrollVoiceRequest$1 {
@@ -8494,6 +8730,14 @@ interface EntailmentRequest$1 {
 }
 /** Response from entailment check. */
 interface EntailmentResponse$1 {
+    /**
+     * How strongly the supplied facts establish the antecedent, μ ∈ [0,1].
+     *
+     * `max { μ⊒(antecedent, f) : f ∈ facts }` — a fact witnesses the antecedent
+     * when the antecedent subsumes it, so a `sparrow` fact supports `animal`.
+     * @format double
+     */
+    antecedent_degree: number;
     /**
      * Computation time in milliseconds
      * @format int64
@@ -8501,10 +8745,31 @@ interface EntailmentResponse$1 {
      */
     computation_time_ms: number;
     /**
-     * Confidence degree
+     * Confidence degree.
+     *
+     * Equal to `degree`. Retained for callers written against the previous
+     * shape, where it was a `1.0`/`0.0` cast of `entails`.
      * @format double
      */
     confidence: number;
+    /**
+     * How strongly the consequent is established, μ ∈ [0,1].
+     *
+     * The better of the two routes: witnessed by the facts, or subsuming the
+     * antecedent it would follow from.
+     * @format double
+     */
+    consequent_degree: number;
+    /**
+     * Graded entailment degree μ ∈ [0,1] — `min(antecedent_degree, consequent_degree)`.
+     *
+     * `entails` is this degree read crisply. A value strictly between 0 and 1
+     * means the two are related only through a fuzzy sort relation (an explicit
+     * `⊑·` degree or an approved sort similarity), not through the crisp
+     * hierarchy.
+     * @format double
+     */
+    degree: number;
     /** Whether antecedent entails consequent */
     entails: boolean;
 }
@@ -8968,6 +9233,20 @@ interface EvidenceItemDto$1 {
      * @format double
      */
     contribution: number;
+    /**
+     * The evidence term's own human-readable sentence, when it has one.
+     *
+     * Without this the only identity an evidence row carried was `term_id`, so
+     * every consumer rendered supporting evidence as `Evidence item <uuid>`
+     * while the term itself held e.g. *"Aspirin reduces_risk_of Cardiovascular
+     * Disease"* — the assessment path reported its own findings unreadably
+     * (#138). Resolved from the term under the same deterministic display-name
+     * precedence `TermDto.display_name` uses, so the two never disagree.
+     *
+     * Optional and omitted when empty: a consumer written before this field
+     * existed deserializes the response unchanged and keeps its own fallback.
+     */
+    description?: string | null;
     /**
      * Quality weight of this evidence (0.0-1.0)
      * @format double
@@ -8995,6 +9274,39 @@ type EvidenceSourceDto$1 = {
     /** @format double */
     unified_degree: number;
 };
+/**
+ * Request to transpile an OSFQL query and run it on the bound source (#133).
+ *
+ * No dialect field: the binding names the source and the source's type
+ * decides the dialect. Asking a caller to supply it would let them ask for
+ * Cypher against Postgres, which is not a question with an answer.
+ */
+interface ExecuteTranspiledRequest {
+    /** OSFQL query to transpile and execute. */
+    osfql: string;
+}
+/** Rows from a live source, with the query that fetched them. */
+interface ExecuteTranspiledResponse {
+    /** Dialect of `query` — `postgres`, `mysql`, `sqlite`, `cypher` or `cql`. */
+    dialect: string;
+    /**
+     * The query that was executed, in the source's own language.
+     *
+     * Returned with the rows rather than behind a separate call: transpile
+     * mode's claim is that OSFQL becomes a native query against the
+     * operator's database, and this is what makes that claim checkable.
+     */
+    query: string;
+    /**
+     * Number of rows returned.
+     * @min 0
+     */
+    row_count: number;
+    /** Rows as returned by the source, one object per record. */
+    rows: any[];
+    /** The source the query ran against. */
+    source_id: string;
+}
 /**
  * ExecutionGoalDto
  * Execution engine goal, discriminated by the 'type' field. Variants: unify, prove, eval, type_disj, cut, if_then_else.
@@ -9333,6 +9645,44 @@ interface ExtractedEntityDto$1 {
     /** The text span that was recognized in the input */
     text: string;
 }
+/** Request body for `POST /api/v1/extraction/certify`. */
+interface ExtractionCertifyRequest {
+    /**
+     * Conformal coverage floor. Defaults to 0.95; only affects conformal (non-sound)
+     * emissions.
+     * @format double
+     */
+    conformal_floor?: number | null;
+    /** Candidate entities, certified in submission order. */
+    entities?: CandidateEntityDto[];
+    /** Candidate relations, certified after the entities. */
+    relations?: CandidateRelationDto[];
+}
+/** Response for `POST /api/v1/extraction/certify`. */
+interface ExtractionCertifyResponse {
+    /**
+     * Candidates the gate withheld.
+     * @min 0
+     */
+    abstained: number;
+    /**
+     * Candidates the gate admitted.
+     * @min 0
+     */
+    emitted: number;
+    /** Per-candidate dispositions, in submission order (entities then relations). */
+    facts: FactOutcomeDto[];
+    /**
+     * Candidates whose certification suspended pending more information.
+     * @min 0
+     */
+    suspended: number;
+    /**
+     * Number of candidates submitted.
+     * @min 0
+     */
+    total: number;
+}
 /** A single extraction prediction. */
 interface ExtractionPredictionDto$1 {
     /**
@@ -9462,6 +9812,39 @@ interface FactConfidenceEntry$1 {
      */
     term_id: string;
 }
+/** The gate's disposition for one candidate fact. */
+interface FactOutcomeDto {
+    /**
+     * Content-addressed id of the persisted certificate, for every disposition —
+     * refusals included, so a withheld verdict stays addressable in the audit trail.
+     */
+    certificate?: string | null;
+    /**
+     * Verdict confidence (`1.0` for a sound proof). Only meaningful for `emitted`.
+     * @format double
+     */
+    confidence?: number | null;
+    /** `emitted`, `suspended`, or `abstained`. */
+    disposition: string;
+    /**
+     * Stable diagnostic label: `entity:<Sort>:<local_id>` or
+     * `relation:<predicate>:<source>→<target>`.
+     */
+    label: string;
+    /**
+     * `true` when the verdict was a sound proof rather than a conformal emission.
+     * Only meaningful for `emitted`.
+     */
+    proven?: boolean | null;
+    /** For `abstained`: why the candidate was withheld. */
+    reason?: string | null;
+    /** Lattice-derived repair suggestions, aligned with `violations`. */
+    repair_hints?: RepairHintDto[];
+    /** Declared obligations this candidate broke. Non-empty only for a refutation. */
+    violations?: ViolationDto$1[];
+    /** For `suspended`: the facts whose arrival should resume certification. */
+    wake_triggers?: string[];
+}
 /**
  * Response for the factory-reset operation.
  *
@@ -9469,10 +9852,23 @@ interface FactConfidenceEntry$1 {
  * so operators can verify the operation succeeded.
  */
 interface FactoryResetResponse$1 {
+    /**
+     * Number of SQL ontology bindings dropped across all tenants
+     * @min 0
+     */
+    bindings_deleted?: number;
     /** Whether the cache (Valkey / in-memory) was flushed */
     cache_cleared: boolean;
     /** Human-readable summary message */
     message: string;
+    /**
+     * The tables that were truncated.
+     *
+     * Discovered from the live schema rather than hard-coded, so this is the
+     * only way for a caller to tell a complete reset from one whose discovery
+     * came back short (#124).
+     */
+    postgres_tables?: string[];
     /**
      * Number of PostgreSQL tables that were truncated
      * @min 0
@@ -11285,6 +11681,41 @@ interface GetFactsResponse$1 {
     /** List of facts */
     facts: PsiTermDto$1[];
 }
+/** Request to read the fuzzy subsumption degree `sub ⊑· sup` */
+interface GetFuzzySubsumptionRequest {
+    /**
+     * The subsumed (more specific) sort
+     * @format uuid
+     */
+    sub_sort_id: string;
+    /**
+     * The subsuming (more general) sort
+     * @format uuid
+     */
+    sup_sort_id: string;
+}
+/** Response for a fuzzy subsumption query */
+interface GetFuzzySubsumptionResponse {
+    /**
+     * Subsumption degree ⊑·(sub, sup) ∈ [0,1]
+     *
+     * Falls back through the explicit relation, then approved similarity,
+     * then the crisp hierarchy — so `1.0` may mean a crisp subtype edge
+     * rather than an explicitly asserted degree.
+     * @format double
+     */
+    degree: number;
+    /**
+     * The subsumed sort
+     * @format uuid
+     */
+    sub_sort_id: string;
+    /**
+     * The subsuming sort
+     * @format uuid
+     */
+    sup_sort_id: string;
+}
 /** Request to get HTN methods. */
 interface GetHtnMethodsRequest {
     /**
@@ -12409,6 +12840,46 @@ interface IdentifyEffectResponse$1 {
     /** Treatment variable */
     treatment: string;
 }
+/**
+ * Optional overrides for identification. Every field defaults to the MEDIA
+ * setting, which is stricter than the meeting path's.
+ */
+interface IdentifyOptionsDto {
+    /**
+     * Minimum cosine to accept a match (default 0.6, vs 0.5 for meetings).
+     * @format float
+     */
+    match_threshold?: number | null;
+    /**
+     * Minimum seconds of speech for a cluster to be reported (default 5).
+     * @format double
+     */
+    min_speech_secs?: number | null;
+    /**
+     * Run vocal separation first (default `true`) — what lets a voice under
+     * music be matched at all.
+     */
+    separate?: boolean | null;
+}
+/** Request to identify which enrolled voices speak in a piece of audio. */
+interface IdentifySpeakersRequest {
+    /** Base64-encoded audio to analyze (any container the transcriber decodes). */
+    audio: string;
+    /** MIME hint (e.g. `"audio/webm"`). */
+    audio_mime?: string | null;
+    /** Tuning knobs; omitted means the media defaults. */
+    options?: null | IdentifyOptionsDto;
+}
+/** Response from identifying voices in audio. */
+interface IdentifySpeakersResponse {
+    detections: SpeakerDetectionDto[];
+    /** @format double */
+    duration_secs: number;
+    /** Whether vocal separation actually ran. */
+    separated: boolean;
+    unknown_clusters: UnknownClusterDto[];
+    warnings: string[];
+}
 /** An entity extracted from a visual element in the image. */
 interface ImageExtractedEntityDto$1 {
     /**
@@ -14782,6 +15253,12 @@ interface ListSourcesResponse$1 {
 }
 /** Response listing a tenant's speaker profiles. */
 interface ListSpeakersResponse$1 {
+    /**
+     * The same profiles grouped by person, since one name may now hold
+     * several samples and the UI lists people, not embeddings.
+     */
+    people?: SpeakerPersonDto[];
+    /** Every stored profile, one entry per sample. */
     speakers: SpeakerProfileDto[];
 }
 /** Request to list module symbols */
@@ -17455,7 +17932,15 @@ interface OsfDiffRequestDto {
     a: object;
     /** Selector for side B */
     b: object;
+    /**
+     * Include the clause section — terms sorted under the tenant's
+     * `document.clause` vocabulary (default true)
+     */
     include_clause_diff?: boolean;
+    /**
+     * Include the entity section — everything outside the tenant's
+     * `document.clause` vocabulary (default true)
+     */
     include_entity_diff?: boolean;
     /**
      * Minimum match degree (default 0.7)
@@ -17660,6 +18145,16 @@ interface OsfqlRequest$1 {
      * clients are byte-identical.
      */
     reactive?: boolean;
+    /**
+     * Which data model the program is answered under.
+     *
+     * **Set this to `rdf` when running a statement returned by
+     * `POST /api/v1/sparql/translate`** — that is the whole point of the switch. It is a
+     * single flag rather than several because the settings it carries are not
+     * independently useful here: getting one right and another wrong yields answers that
+     * are silently wrong rather than obviously broken.
+     */
+    semantics?: OsfqlSemantics;
 }
 /** Response from executing an OSFQL program. */
 interface OsfqlResponse$1 {
@@ -17690,6 +18185,8 @@ interface OsfqlResponse$1 {
      */
     updated_term_ids?: string[];
 }
+/** The data model an OSFQL program is answered under — see [`OsfqlRequest::semantics`]. */
+type OsfqlSemantics = "osf" | "rdf";
 /** A bound value in an OSFQL result. */
 type OsfqlValueDto = {
     type: "null";
@@ -17715,6 +18212,13 @@ type OsfqlValueDto = {
     type: "boolean";
     /** Boolean value. */
     value: boolean;
+} | {
+    type: "datetime";
+    /**
+     * UTC datetime instant, rendered in its RFC 3339 `Z`-suffixed form — the value
+     * of a `date`/`timestamp` feature binding (or a MIN/MAX aggregate over one).
+     */
+    value: string;
 } | {
     type: "list";
     /** Ordered list value. */
@@ -19687,6 +20191,15 @@ interface ReleaseResiduationsResponse$1 {
     /** @min 0 */
     remaining_suspended: number;
 }
+/** A lattice-derived suggestion for discharging one violated obligation. */
+interface RepairHintDto {
+    /** Why that replacement discharges it. */
+    rationale: string;
+    /** The concrete replacement that would discharge the obligation. */
+    suggestion: string;
+    /** The feature or predicate the hint applies to. */
+    target: string;
+}
 /** Request to reprocess failed documents */
 interface ReprocessFailedRequest {
     /**
@@ -20036,6 +20549,13 @@ interface ResumptionOptionDto$1 {
     /** Unique identifier for this option */
     id: string;
 }
+/** One table a tenant erasure deliberately left standing, and why. */
+interface RetainedTableDto {
+    /** Why this table survives a tenant erasure */
+    reason: string;
+    /** Table name in the `public` schema */
+    table: string;
+}
 /** Request to retract a rule */
 interface RetractRuleRequest$1 {
     /** If provided, retract rules matching this pattern */
@@ -21602,6 +22122,37 @@ interface SetFeatureResponse$1 {
     success: boolean;
     term_id: string;
 }
+/**
+ * Request to set the fuzzy subsumption degree `sub ⊑· sup`
+ *
+ * The field names are `sub`/`sup` rather than `sort1`/`sort2` because the
+ * relation is **directional**: swapping them asserts something else. The
+ * symmetric relation is `/api/v1/sorts/similarity`.
+ */
+interface SetFuzzySubsumptionRequest {
+    /**
+     * Subsumption degree ∈ [0,1]
+     * @format double
+     */
+    degree: number;
+    /**
+     * The subsumed (more specific) sort
+     * @format uuid
+     */
+    sub_sort_id: string;
+    /**
+     * The subsuming (more general) sort
+     * @format uuid
+     */
+    sup_sort_id: string;
+}
+/** Response for setting a fuzzy subsumption degree */
+interface SetFuzzySubsumptionResponse {
+    /** Message */
+    message: string;
+    /** Whether the operation succeeded */
+    success: boolean;
+}
 /**
  * Request to transition a goal to a terminal status.
  *
@@ -21945,17 +22496,43 @@ interface SoftUnifyRequest$1 {
 }
 /** Response for soft unification. */
 interface SoftUnifyResponse$1 {
-    /** @format double */
+    /**
+     * Combined confidence μ ∈ [0,1] — the product of `sort_score` and
+     * `feature_score`, per the domain's soft-unification quantale.
+     * @format double
+     */
     confidence: number;
     /**
+     * Wall-clock time for the computation.
      * @format int64
      * @min 0
      */
     elapsed_ms: number;
-    /** @format double */
+    /**
+     * Whether a box-embedding adapter contributed to `sort_score`.
+     *
+     * `false` means the sort axis was scored from the hierarchy alone
+     * (subsumption and fuzzy subsumption). The scores are measured either way —
+     * this reports which evidence was available, so a caller can tell a
+     * hierarchy-only answer from an embedding-backed one.
+     */
+    embeddings_used: boolean;
+    /**
+     * Feature compatibility μ ∈ [0,1], averaged over the union of both terms'
+     * features. A feature only one side carries scores 0.5 (open world), not 0.
+     * @format double
+     */
     feature_score: number;
+    /**
+     * What hard OSF unification says about the same pair. Independent of the
+     * scores above: terms can be highly similar and still fail to unify.
+     */
     hard_compatible: boolean;
-    /** @format double */
+    /**
+     * Sort compatibility μ ∈ [0,1]: exact match or subsumption → 1.0, then box
+     * containment, then fuzzy subsumption.
+     * @format double
+     */
     sort_score: number;
 }
 /** A solution from backward chaining or open-world inference. */
@@ -23006,6 +23583,23 @@ type SpaceStatusDto$1 = {
     count: number;
     type: "alternatives";
 };
+/** A recognized voice. */
+interface SpeakerDetectionDto {
+    name: string;
+    /**
+     * Cosine similarity of the accepted match.
+     * @format float
+     */
+    score: number;
+    spans: SpeechSpanDto[];
+    /** @format double */
+    speech_secs: number;
+}
+/** One person and all the samples enrolled for them. */
+interface SpeakerPersonDto {
+    name: string;
+    profiles: SpeakerProfileDto[];
+}
 /** A stored speaker profile (embedding withheld). */
 interface SpeakerProfileDto {
     /** ISO-8601 timestamp of enrollment. */
@@ -23022,6 +23616,8 @@ interface SpeakerProfileDto {
      * @format double
      */
     sample_secs: number;
+    /** Sample label, when one was supplied at enrollment. */
+    variant?: string | null;
 }
 /** Volume-specificity verification sub-DTO. */
 interface SpecificityDto$1 {
@@ -23062,6 +23658,13 @@ interface SpeechEngineDto {
     /** Whether it can clone from a reference clip. */
     supports_cloning: boolean;
 }
+/** One speaking interval, in seconds from the start of the audio. */
+interface SpeechSpanDto {
+    /** @format double */
+    end: number;
+    /** @format double */
+    start: number;
+}
 /**
  * Request to start a new attribute exploration session.
  *
@@ -23359,6 +23962,35 @@ interface StructuredIngestionStatsDto$1 {
      */
     terms_projected: number;
 }
+/** What a subject erasure matched, and what it removed. */
+interface SubjectErasureReport {
+    /** Whether this call executed, or only planned. */
+    confirmed: boolean;
+    /** The data subject named by the request being fulfilled. */
+    data_subject: string;
+    /** Feature that was matched on. */
+    feature: string;
+    /** Ids of every term matching the subject, whether or not they were erased. */
+    matched_terms: string[];
+    /**
+     * Terms actually removed (zero on a dry run).
+     * @min 0
+     */
+    terms_deleted: number;
+}
+/** Body for fulfilling an erasure request against the knowledge base. */
+interface SubjectErasureRequest {
+    /** Execute the erasure. Defaults to false — a dry run returning the plan. */
+    confirm?: boolean;
+    /**
+     * Which feature holds the subject's identifier (e.g. `"name"`, `"email"`).
+     *
+     * Named by the caller rather than guessed: only the operator knows which
+     * feature identifies a person in their schema, and guessing wrong would
+     * either miss the subject's data or match somebody else's.
+     */
+    feature: string;
+}
 /** Request to subscribe agent to KB changes. */
 interface SubscribeToKbRequest$1 {
     /**
@@ -24049,7 +24681,14 @@ interface TermBindingDto$1 {
 }
 /** API representation of a term */
 interface TermDto$1 {
-    /** Human-readable display name extracted from features (name/label/title/...) */
+    /**
+     * Human-readable display name extracted from features under a total,
+     * deterministic precedence: a feature the sort annotates `displayLabel`,
+     * then one annotated `isIdentifier`, then the conventional keys
+     * (name/label/title/...), then the sort's declared feature order, then
+     * undeclared features in lexicographic key order. The same term always
+     * yields the same value.
+     */
     display_name?: string | null;
     /** Features map */
     features: Record<string, ValueDto$1>;
@@ -24221,6 +24860,44 @@ interface TestInputDto {
     /** Caller-assigned identifier echoed in the response. */
     input_id: string;
 }
+/** Run the caller's own system prompt over a piece of text. */
+interface TextGenerateRequest {
+    /**
+     * Output-token cap for one model call. Clamped down to the deployment's
+     * own maximum — the engine's per-sequence budget covers prompt AND
+     * generation, and the caller does not know it.
+     * @format int32
+     * @min 0
+     */
+    max_tokens?: number | null;
+    /**
+     * The system prompt, applied verbatim.
+     *
+     * This is the whole point of the endpoint. A client that versions its own
+     * prompts (and stands behind the pairing of prompt version + output) must
+     * be able to send the prompt it versioned; a service-side rewording would
+     * silently answer a different question.
+     */
+    system: string;
+    /**
+     * Decode temperature. Absent = greedy, the only setting under which a
+     * versioned prompt yields a reproducible answer.
+     * @format float
+     */
+    temperature?: number | null;
+    /**
+     * The text to transform. Sent to the model as the user turn, verbatim —
+     * never wrapped — so the answer stays diff-able against the input.
+     */
+    text: string;
+}
+/** The generated text. */
+interface TextGenerateResponse {
+    /** Label of the backend that answered, when known. */
+    model?: string | null;
+    /** The model's answer, trimmed of surrounding whitespace. */
+    text: string;
+}
 /** Threshold-based weak anchor for an antecedent gate. */
 interface ThresholdAnchorDto {
     /**
@@ -25241,6 +25918,17 @@ interface UnifyTermsResponse$1 {
     /** The resulting unified term ID (if successful) */
     unified_term_id?: string | null;
 }
+/**
+ * A cluster that carried enough speech to report but matched no profile —
+ * the raw material for "this is …" enrollment from media.
+ */
+interface UnknownClusterDto {
+    /** @format int32 */
+    cluster: number;
+    spans: SpeechSpanDto[];
+    /** @format double */
+    speech_secs: number;
+}
 /** Request to update a collection */
 interface UpdateCollectionRequest$1 {
     /** Optional description */
@@ -25425,6 +26113,37 @@ interface UpgradeRequest {
     /** The content-addressed bundle id of the target version (UUID string). */
     to_bundle_id: string;
 }
+/**
+ * Metadata for a tenant-uploaded file-based source artifact (#107).
+ *
+ * Returned by `POST /api/v1/sources/files` (the upload) and listed by
+ * `GET /api/v1/sources/files`. The `path` is the engine-internal location
+ * written into a registered source's `config.file_path` (csv/parquet) or
+ * `config.database_path` (sqlite); the api-layer path-traversal guard
+ * accepts exactly these uploaded paths (plus configured allow-tree entries).
+ * `uploaded_at` follows the `chrono::DateTime<chrono::Utc>` convention used
+ * by `SourceSummaryDto::last_sync_at` so the field round-trips through the
+ * same utoipa `chrono` schema generator as the rest of the ingestion DTOs.
+ */
+interface UploadedSourceFileDto {
+    /** The `SourceFileId` (UUID v4) of the upload, also the `{id}` path param. */
+    id: string;
+    /** Sanitized basename of the uploaded file (no path separators). */
+    name: string;
+    /** Engine-internal absolute path the registered source's config points at. */
+    path: string;
+    /**
+     * Size of the stored file in bytes.
+     * @format int64
+     * @min 0
+     */
+    size: number;
+    /**
+     * Upload timestamp (RFC 3339 UTC).
+     * @format date-time
+     */
+    uploaded_at: string;
+}
 /** @format uuid */
 type UserId = string;
 /**
@@ -26314,6 +27033,15 @@ declare class Sorts<SecurityDataType = unknown> {
      * @request GET:/api/v1/sorts/equivalence-classes
      */
     getEquivalenceClasses: (params?: RequestParams) => Promise<HttpResponse<GetEquivalenceClassesResponse$1, any>>;
+    /**
+     * No description
+     *
+     * @tags sorts
+     * @name GetFuzzySubsumption
+     * @summary Get the fuzzy subsumption degree `sub ⊑· sup` between two sorts
+     * @request POST:/api/v1/sorts/subsumption/get
+     */
+    getFuzzySubsumption: (data: GetFuzzySubsumptionRequest, params?: RequestParams) => Promise<HttpResponse<GetFuzzySubsumptionResponse, any>>;
     /**
      * @description Per Definition IV.5 (Milanese & Pasi 2024): ≾̇ = ((≾̃ .− ∼) ⊍ ≤)⁺
      *
@@ -26324,14 +27052,21 @@ declare class Sorts<SecurityDataType = unknown> {
      */
     getPreorderDegree: (data: GetPreorderDegreeRequest$1, params?: RequestParams) => Promise<HttpResponse<GetPreorderDegreeResponse$1, any>>;
     /**
-     * No description
+     * @description With `?format=osfql` the sort is returned as its commented OSFQL `DEFINE` block (`text/plain`, `ETag` = SHA-256 of the body) instead of the JSON DTO — the single-sort companion of `GET /api/v1/sorts/schema`.
      *
      * @tags sorts
      * @name GetSort
      * @summary Get a sort by ID
      * @request GET:/api/v1/sorts/{id}
      */
-    getSort: (id: string, params?: RequestParams) => Promise<HttpResponse<SortResponse$1, void>>;
+    getSort: (id: string, query?: {
+        /**
+         * Optional response format. `osfql` renders the sort as its commented
+         * `DEFINE` DDL (`text/plain`); `json` (or absent) keeps the JSON DTO.
+         * The bulk schema route (`/api/v1/sorts/schema`) accepts only `osfql`.
+         */
+        format?: string | null;
+    }, params?: RequestParams) => Promise<HttpResponse<SortResponse$1, void>>;
     /**
      * No description
      *
@@ -26341,6 +27076,55 @@ declare class Sorts<SecurityDataType = unknown> {
      * @request POST:/api/v1/sorts/similarity/get
      */
     getSortSimilarity: (data: GetSortSimilarityRequest$1, params?: RequestParams) => Promise<HttpResponse<GetSortSimilarityResponse$1, any>>;
+    /**
+     * @description The bulk companion of `?format=osfql` on the by-id route: a single deterministic, re-parseable `text/plain` block of commented `DEFINE` statements (one per sort, ordered by name) for LLM prompt conditioning and replayable export. Supports the tenant listing's filters (`name_prefix`, `include_system`, `needs_review`, `llm_extracted`, and `offset`/`limit`, applied after the deterministic ordering so pages are stable). The `ETag` is the SHA-256 of the body, so prompt-conditioning consumers get a stable cache key for "schema unchanged".
+     *
+     * @tags sorts
+     * @name GetSortsSchema
+     * @summary Export the authenticated tenant's schema as one OSFQL DDL block
+     * @request GET:/api/v1/sorts/schema
+     * @secure
+     */
+    getSortsSchema: (query?: {
+        /**
+         * Optional response format. `osfql` renders the sort as its commented
+         * `DEFINE` DDL (`text/plain`); `json` (or absent) keeps the JSON DTO.
+         * The bulk schema route (`/api/v1/sorts/schema`) accepts only `osfql`.
+         */
+        format?: string | null;
+        /**
+         * Include system-defined sorts in the response.
+         * System sorts are built-in types like Thing, Person, etc.
+         * Defaults to false (system sorts are excluded by default).
+         */
+        include_system?: boolean;
+        /**
+         * Maximum number of sorts to return. When omitted, no cap is
+         * applied (legacy behaviour). Recommended page size for
+         * production tenants: 50_000.
+         * @min 0
+         */
+        limit?: number | null;
+        /** Filter to only show LLM-extracted sorts */
+        llm_extracted?: boolean | null;
+        /**
+         * Filter to sorts whose name starts with this prefix.
+         * Supports comma-separated multiple prefixes (e.g. "drug_,target_,pathway_,disease_").
+         * Server-side filtering avoids transferring millions of irrelevant sorts.
+         */
+        name_prefix?: string | null;
+        /** Filter to only show sorts needing review */
+        needs_review?: boolean | null;
+        /**
+         * Zero-indexed pagination offset. Combined with ``limit`` this
+         * lets clients stream a production tenant (1 M+ sorts, ~500 MB
+         * uncompressed) as a sequence of small responses, avoiding the
+         * ``IncompleteRead`` a single-response transfer reliably hits
+         * above ~30 MB.
+         * @min 0
+         */
+        offset?: number | null;
+    }, params?: RequestParams) => Promise<HttpResponse<string, void>>;
     /**
      * No description
      *
@@ -26445,6 +27229,15 @@ declare class Sorts<SecurityDataType = unknown> {
         /** Search query (sort name substring) */
         q: string;
     }, params?: RequestParams) => Promise<HttpResponse<SearchSortsResponse, any>>;
+    /**
+     * @description Subsumption is **directional**: ⊑·(s₁, s₂) and ⊑·(s₂, s₁) are different assertions. For the symmetric relation use `/api/v1/sorts/similarity`. The degree must be in [0, 1] and the assignment must keep the relation a fuzzy partial order (max–min transitivity, antisymmetry); one that does not is rejected rather than stored.
+     *
+     * @tags sorts
+     * @name SetFuzzySubsumption
+     * @summary Set the fuzzy subsumption degree `sub ⊑· sup` between two sorts
+     * @request POST:/api/v1/sorts/subsumption
+     */
+    setFuzzySubsumption: (data: SetFuzzySubsumptionRequest, params?: RequestParams) => Promise<HttpResponse<SetFuzzySubsumptionResponse, any>>;
     /**
      * @description Similarity is symmetric: ∼(s₁, s₂) = ∼(s₂, s₁) Degree must be in [0, 1] range.
      *
@@ -29120,11 +29913,11 @@ declare class Inference<SecurityDataType = unknown> {
      */
     bulkRetractTerms: (data: BulkRetractTermsRequest, params?: RequestParams) => Promise<HttpResponse<BulkRetractTermsResponse, any>>;
     /**
-     * @description # DEPRECATED This endpoint is deprecated. Use `DELETE /api/v1/terms/{term_id}` for individual terms. # TRUE HOMOICONIC API # Authorization Requires X-Tenant-Id header.
+     * @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.
      *
      * @tags inference
      * @name ClearFacts
-     * @summary Clear all facts and rules for a tenant
+     * @summary Clear a tenant's in-memory inference working set.
      * @request DELETE:/api/v1/inference/facts/{tenant_id}
      * @secure
      */
@@ -30653,7 +31446,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.
+     * @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, in order, and the first that answers wins; only `SortNotFound` moves on to the next, every other failure is returned as-is. When the first candidate answers — the common case — the route runs exactly one term query, as it always did. 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.
      *
      * @tags query
      * @name FindBySort
@@ -42351,7 +43144,7 @@ declare class Reasoning<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
     /**
-     * @description POST /api/v1/reasoning/disentailment Disentailment A =/=> B means: "if A holds, then B must NOT hold" Returns whether the disentailment is violated (conflict: both A and B hold)
+     * @description POST /api/v1/reasoning/disentailment Disentailment A =/=> B means: "if A holds, then B must NOT hold". Returns whether the disentailment is violated — the conflict where the facts establish A and B follows anyway. This is hierarchy-aware and graded on the same footing as the entailment route, so a conflict reachable only through the sort lattice (a `contaminated` clause held by a `lead_paint` fact that subsumes it) is detected without that clause being supplied as a fact. `A ⇏ B` is violated exactly to the degree `A ⇒ B` is established, so `degree` here reports the complement: how strongly the disentailment still holds.
      *
      * @tags reasoning
      * @name Disentailment
@@ -42360,7 +43153,7 @@ declare class Reasoning<SecurityDataType = unknown> {
      */
     disentailment: (data: DisentailmentRequest$1, params?: RequestParams) => Promise<HttpResponse<DisentailmentResponse$1, any>>;
     /**
-     * @description POST /api/v1/reasoning/entailment Returns whether antecedent entails consequent
+     * @description POST /api/v1/reasoning/entailment Answers `facts ⊨ antecedent ⇒ consequent`, hierarchy-aware and graded. A clause holds in the fact base to the degree that some fact *witnesses* it — that is, to the degree the clause subsumes a fact — so a `sparrow` fact establishes the clause `animal` without an `animal` fact being supplied. The consequent is additionally established when it subsumes the antecedent it would follow from. See [`osfkb_domain::operations::homoiconic_entailment`] for the full semantics. `entails` is the crisp reading of `degree`; `degree`, `antecedent_degree` and `consequent_degree` are computed from the sort lattice (crisply, and through explicit fuzzy `⊑·` relations and approved sort similarity), never cast from the boolean.
      *
      * @tags reasoning
      * @name Entailment
@@ -42540,6 +43333,19 @@ interface EvidenceAssessmentRequest {
 interface EvidenceItemDto {
     /** Contribution to the assessment (quality * support direction). */
     contribution: number;
+    /**
+     * The evidence term's own human-readable sentence, e.g.
+     * `"Aspirin reduces_risk_of Cancer"`.
+     *
+     * `termId` is a UUID no consumer can render, so without this an evidence row
+     * could only be shown as `Evidence item <uuid>`. The backend resolves it from
+     * the term under the same display-name precedence `TermDto.displayName` uses,
+     * so the sentence shown here and the one shown for the term never disagree.
+     *
+     * `null` when talking to a backend that predates evidence descriptions, or
+     * when the evidence term carries no description of its own.
+     */
+    description?: string | null;
     /** Quality weight of this evidence (0.0-1.0). */
     qualityWeight: number;
     /** Whether this evidence supports (true) or contradicts (false) the subject. */
@@ -42818,6 +43624,13 @@ declare class ReasoningClient {
     /**
      * Assess the truthfulness/validity of a subject based on related evidence.
      *
+     * @remarks
+     * Each item in the supporting/contradicting breakdown carries a
+     * `description` — the evidence term's own sentence,
+     * e.g. `"Aspirin reduces_risk_of Cancer"` — so evidence can be rendered
+     * without a second lookup by `termId`. It is `null` against a backend that
+     * predates the field.
+     *
      * @param request - Evidence assessment request.
      * @returns Assessment result with truthfulness score, label, and evidence breakdown.
      */
@@ -45217,6 +46030,16 @@ declare class StructuredIngestion<SecurityDataType = unknown> {
      * @secure
      */
     deleteSource: (sourceId: string, params?: RequestParams) => Promise<HttpResponse<void, void>>;
+    /**
+     * @description Refused with 409 while a registered source still references the file's path (the source's adapter would otherwise hold a dangling `file_path`). After that source is unregistered, the delete succeeds (204). A missing sidecar (no such upload id) is 404.
+     *
+     * @tags structured_ingestion
+     * @name DeleteSourceFile
+     * @summary Delete a tenant-uploaded source file (#107).
+     * @request DELETE:/api/v1/sources/files/{id}
+     * @secure
+     */
+    deleteSourceFile: (id: string, params?: RequestParams) => Promise<HttpResponse<void, void>>;
     /**
      * @description Performs schema introspection on the source to discover types (sorts), features (fields), and relations. This is a preview operation - no data is ingested. `type_filter` narrows the discovery to a named subset **without re-registering the source** — the escape hatch a client uses after `/tables` when the source is over the discovery cap (#66, Gap 2). It conjoins with the source config's own `include_tables`: a request narrows *within* the registration, it cannot widen past it.
      *
@@ -45247,6 +46070,16 @@ declare class StructuredIngestion<SecurityDataType = unknown> {
      * @secure
      */
     ingestFromSource: (sourceId: string, data: IngestFromSourceRequest$1, params?: RequestParams) => Promise<HttpResponse<IngestFromSourceResponse$1, void>>;
+    /**
+     * @description Walks `{base}/{tenant_id}/*\/​.meta.json`. A missing tenant dir yields an empty list (200), not 404 — a tenant that never uploaded is not an error.
+     *
+     * @tags structured_ingestion
+     * @name ListSourceFiles
+     * @summary List the calling tenant's uploaded source files (#107).
+     * @request GET:/api/v1/sources/files
+     * @secure
+     */
+    listSourceFiles: (params?: RequestParams) => Promise<HttpResponse<UploadedSourceFileDto[], any>>;
     /**
      * No description
      *
@@ -45287,6 +46120,16 @@ declare class StructuredIngestion<SecurityDataType = unknown> {
      * @secure
      */
     registerSource: (data: RegisterSourceRequest$1, params?: RequestParams) => Promise<HttpResponse<RegisterSourceResponse$1, void>>;
+    /**
+     * @description Multipart, one field named `file`. Streamed to disk under `{base}/{tenant_id}/{id}/{safe_name}` with a `.meta.json` sidecar. The response `path` is the engine-internal location handed to `POST /api/v1/sources` as `config.file_path` (csv/parquet) or `config.database_path` (sqlite).
+     *
+     * @tags structured_ingestion
+     * @name UploadSourceFile
+     * @summary Upload a file-based source artifact for the calling tenant (#107).
+     * @request POST:/api/v1/sources/files
+     * @secure
+     */
+    uploadSourceFile: (data: string, params?: RequestParams) => Promise<HttpResponse<UploadedSourceFileDto, void>>;
 }
 
 /**
@@ -47998,6 +48841,15 @@ declare class DiscoveryClient {
 declare class Extraction<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * @description Read-only with respect to the knowledge base: certification inspects the tenant's sort lattice and never writes a term. Certificates *are* written to the verification certificate store, so the batch is auditable afterwards.
+     *
+     * @tags extraction
+     * @name CertifyExtraction
+     * @summary `POST /api/v1/extraction/certify` — gate a batch of extraction candidates through the OSF well-sortedness certifier before they may become durable KB content.
+     * @request POST:/api/v1/extraction/certify
+     */
+    certifyExtraction: (data: ExtractionCertifyRequest, params?: RequestParams) => Promise<HttpResponse<ExtractionCertifyResponse, void>>;
     /**
      * @description Uses GLiNER2 (zero-shot NER) with sort names from the tenant's knowledge base, guaranteeing that all returned entity labels are valid sort names. Label selection (when no explicit labels provided): Embed the input text and ANN-search the pre-computed sort embedding index (Qdrant) for the most semantically similar HPO sorts. This is O(log n) and typically returns 20-100 highly relevant labels from 19K+ HPO sorts. Requires: - GLiNER2 NER service (`GLINER_NER_URL`) - Qdrant vector store for semantic label selection If either is not configured, returns a 500 error.
      *
@@ -48096,6 +48948,16 @@ declare class DocumentAnalysis<SecurityDataType = unknown> {
 declare class Documents<SecurityDataType = unknown> {
     http: HttpClient<SecurityDataType>;
     constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * No description
+     *
+     * @tags documents
+     * @name EraseDocument
+     * @summary Erase a document and everything extracted from it
+     * @request DELETE:/api/v1/documents/{id}
+     * @secure
+     */
+    eraseDocument: (id: string, params?: RequestParams) => Promise<HttpResponse<DocumentErasureReport, void>>;
     /**
      * No description
      *
@@ -52708,6 +53570,15 @@ declare class Health<SecurityDataType = unknown> {
      * @request GET:/health
      */
     healthCheck: (params?: RequestParams) => Promise<HttpResponse<EnrichedHealthResponse$1, EnrichedHealthResponse$1>>;
+    /**
+     * No description
+     *
+     * @tags health
+     * @name HealthCheckApi
+     * @summary `GET /api/v1/health` — the same enriched health check under the `/api/v1` prefix. The playground front proxy forwards only `/api/*` to the engine (and answers the bare `/health` itself with a static OK), so THIS is the path that makes the deployed `build_info.version` publicly readable — a stale rollout must never be indistinguishable from a fresh one.
+     * @request GET:/api/v1/health
+     */
+    healthCheckApi: (params?: RequestParams) => Promise<HttpResponse<EnrichedHealthResponse$1, EnrichedHealthResponse$1>>;
 }
 
 /** Build information from the backend server. */
@@ -53434,6 +54305,16 @@ declare class Generation<SecurityDataType = unknown> {
      * @secure
      */
     generateDocument: (data: GenerateDocumentRequest$1, params?: RequestParams) => Promise<HttpResponse<GenerateDocumentResponse$1, void>>;
+    /**
+     * @description POST /api/v1/text/generate
+     *
+     * @tags generation
+     * @name GenerateText
+     * @summary Run the caller's system prompt over their text.
+     * @request POST:/api/v1/text/generate
+     * @secure
+     */
+    generateText: (data: TextGenerateRequest, params?: RequestParams) => Promise<HttpResponse<TextGenerateResponse, void>>;
     /**
      * @description Returns `503` when no in-process Gemma is loaded (server started without `OSFKB_OSFQL_GEMMA_DIR`), `400` on an empty prompt, and `422` when the tenant has no persisted lattice to constrain to (ingest a theory with `persist:true` first).
      *
@@ -56229,6 +57110,33 @@ interface PaperMetadataDto {
     source: PaperSource;
     /** URL to full text. */
     fullTextUrl?: string | null;
+    /**
+     * Stable paper identity (`doi:…`, `pmid:…`, `arxiv:…` or `title:…`).
+     *
+     * The join key between a paper listed on a session and the `paperKey`
+     * carried by findings, evidence items and contradiction sides — `doi`,
+     * `pmid` and `arxivId` are each individually optional, so this is the only
+     * identifier guaranteed for every paper. `null` only when talking to a
+     * backend that predates paper attribution.
+     */
+    paperKey?: string | null;
+}
+/**
+ * A citable reference to the paper a statement came from.
+ *
+ * Claims, evidence items and contradiction sides are keyed internally by
+ * OSFKB term UUIDs, which no consumer can resolve back to a document. This is
+ * the resolvable counterpart: `paperKey` is the stable identity, and
+ * `doi`/`title` are carried alongside so rendering a citation needs no second
+ * lookup.
+ */
+interface PaperRefDto {
+    /** Stable paper identity (`doi:…`, `pmid:…`, `arxiv:…` or `title:…`). */
+    paperKey: string;
+    /** DOI of the paper, when it has one. */
+    doi?: string | null;
+    /** Paper title, for display. */
+    title: string;
 }
 /** A search result with relevance score. */
 interface PaperSearchResultDto {
@@ -56280,6 +57188,13 @@ interface ResearchSessionResponse {
     error?: string | null;
     /** Results from each completed cycle. */
     cycles: ResearchCycleResultDto[];
+    /**
+     * Papers ingested so far, with full metadata (title, authors, DOI, URL).
+     *
+     * This is the session's actual corpus — `totalPapersIngested` is only its
+     * length. Empty against a backend that does not send it.
+     */
+    papers: PaperMetadataDto[];
     /** Total papers ingested. */
     totalPapersIngested: number;
     /** Total findings. */
@@ -56335,6 +57250,10 @@ interface ResearchCycleResultDto {
     claimsVerified: number;
     /** Contradictions detected. */
     contradictionsDetected: number;
+    /** Contradictions resolved via evidence comparison. `0` if the backend omits it. */
+    contradictionsResolved: number;
+    /** Claims merged via entailment detection. `0` if the backend omits it. */
+    claimsMerged: number;
     /** Processing time for this cycle in milliseconds. */
     processingTimeMs: number;
     /** Search queries used. */
@@ -56372,6 +57291,14 @@ interface EvidenceItemSummaryDto {
     contribution: number;
     /** DOI of the paper providing this evidence. */
     paperDoi?: string | null;
+    /**
+     * Stable key of the paper providing this evidence.
+     *
+     * Present even when the paper has no DOI, which `paperDoi` cannot cover.
+     */
+    paperKey?: string | null;
+    /** Title of the paper providing this evidence, for display. */
+    paperTitle?: string | null;
 }
 /** A step in the provenance chain. */
 interface ProvenanceStepDto {
@@ -56384,6 +57311,21 @@ interface ProvenanceStepDto {
     /** Timestamp (ISO 8601). */
     timestamp?: string | null;
 }
+/**
+ * A feature that is residuated — suspended because data is missing.
+ *
+ * Per-feature rather than binary at the claim level: each entry names a
+ * specific piece of missing information that, once supplied, would strengthen
+ * or change the assessment.
+ */
+interface ResiduatedFeatureDto {
+    /** Feature name that is missing or incomplete. */
+    featureName: string;
+    /** What sort would satisfy this feature. */
+    neededSort?: string | null;
+    /** Information gain from resolving this feature (0.0-1.0). */
+    infoGain: number;
+}
 /** A verified research finding. */
 interface ResearchFindingDto {
     /** OSFKB term ID of the claim. */
@@ -56404,6 +57346,16 @@ interface ResearchFindingDto {
     residuated: boolean;
     /** Reason for residuation. */
     residuationReason?: string | null;
+    /** Specific features that are residuated, enabling targeted gap filling. */
+    residuatedFeatures: ResiduatedFeatureDto[];
+    /**
+     * Papers the claim was extracted from.
+     *
+     * `claimId` is an OSFKB term UUID and is not resolvable by a consumer; this
+     * is what makes the finding citable. A claim drawn from several papers
+     * carries several refs. Empty when the backend has no attribution for it.
+     */
+    sources: PaperRefDto[];
 }
 /** Response containing research findings. */
 interface ResearchFindingsResponse {
@@ -56436,6 +57388,31 @@ interface ResearchGapsResponse {
     /** Total gaps count. */
     total: number;
 }
+/** Strategy used to resolve a contradiction between two claims. */
+type ResolutionStrategyDto = 'EvidenceStrength' | 'EvidenceCount' | 'Unresolvable';
+/**
+ * Resolution of a detected contradiction, by evidence-strength comparison.
+ *
+ * When two claims contradict, their evidence assessment scores are compared:
+ * the better-supported claim is preferred and the weaker one dismissed. A
+ * `strategy` of `'Unresolvable'` means the two sides were too close to call.
+ */
+interface ContradictionResolutionDto {
+    /** ID of the preferred claim (stronger evidence). */
+    preferredClaimId: string;
+    /** ID of the dismissed claim (weaker evidence). */
+    dismissedClaimId: string;
+    /** Truthfulness score of the preferred claim. */
+    preferredTruthfulness: number;
+    /** Truthfulness score of the dismissed claim. */
+    dismissedTruthfulness: number;
+    /** Strategy used to resolve the contradiction. */
+    strategy: ResolutionStrategyDto;
+    /** Confidence in the resolution (0.0-1.0). */
+    confidence: number;
+    /** Human-readable explanation of the resolution. */
+    explanation: string;
+}
 /** A detected contradiction between two claims. */
 interface ContradictionDto {
     /** OSFKB term ID of the first claim. */
@@ -56450,6 +57427,17 @@ interface ContradictionDto {
     confidence: number;
     /** Explanation of the contradiction. */
     explanation: string;
+    /** Resolution of the contradiction, if it was resolved by evidence comparison. */
+    resolution?: ContradictionResolutionDto | null;
+    /**
+     * Papers the first claim was extracted from.
+     *
+     * Without it "these two claims disagree" is unactionable — a reader cannot
+     * tell which literature each side comes from.
+     */
+    claimASources: PaperRefDto[];
+    /** Papers the second claim was extracted from. */
+    claimBSources: PaperRefDto[];
 }
 /** Response containing contradictions. */
 interface ResearchContradictionsResponse {
@@ -56480,6 +57468,10 @@ interface ResearchStatisticsDto {
     gapsResolved: number;
     /** Knowledge gaps remaining. */
     gapsRemaining: number;
+    /** Claims merged via entailment detection. `0` if the backend omits it. */
+    claimsMerged: number;
+    /** Contradictions resolved via evidence comparison. `0` if the backend omits it. */
+    contradictionsResolved: number;
 }
 /** Report verification result. */
 interface ReportVerificationDto {
@@ -56539,6 +57531,18 @@ interface VerifyClaimRequest {
     claimTermId: string;
     /** Evidence sort ID (UUID). */
     evidenceSortId: string;
+    /**
+     * Session whose knowledge base holds the claim, if any.
+     *
+     * A research session's terms live under a tenant of its own, so a claim a
+     * run produced is invisible to a lookup against the deployment's configured
+     * tenant — name the session and the verification is performed where the term
+     * actually is. Omit it for a claim asserted outside any session.
+     *
+     * The session must belong to the caller's tenant; another tenant's session id
+     * answers 404, exactly as an absent one does.
+     */
+    sessionId?: string | null;
 }
 /** Response from claim verification. */
 interface VerifyClaimResponse {
@@ -56557,6 +57561,7 @@ interface VerifyClaimResponse {
 }
 
 type research_ContradictionDto = ContradictionDto;
+type research_ContradictionResolutionDto = ContradictionResolutionDto;
 type research_CreateResearchSessionRequest = CreateResearchSessionRequest;
 type research_CreateResearchSessionResponse = CreateResearchSessionResponse;
 type research_EvidenceItemSummaryDto = EvidenceItemSummaryDto;
@@ -56565,6 +57570,7 @@ type research_IngestPaperResponse = IngestPaperResponse;
 type research_KnowledgeGapDto = KnowledgeGapDto;
 type research_ListResearchSessionsResponse = ListResearchSessionsResponse;
 type research_PaperMetadataDto = PaperMetadataDto;
+type research_PaperRefDto = PaperRefDto;
 type research_PaperSearchResultDto = PaperSearchResultDto;
 type research_PaperSource = PaperSource;
 type research_ProvenanceStepDto = ProvenanceStepDto;
@@ -56580,13 +57586,15 @@ type research_ResearchSessionResponse = ResearchSessionResponse;
 type research_ResearchSessionStatusDto = ResearchSessionStatusDto;
 type research_ResearchSessionSummaryDto = ResearchSessionSummaryDto;
 type research_ResearchStatisticsDto = ResearchStatisticsDto;
+type research_ResiduatedFeatureDto = ResiduatedFeatureDto;
+type research_ResolutionStrategyDto = ResolutionStrategyDto;
 type research_RunResearchCycleRequest = RunResearchCycleRequest;
 type research_SearchPapersRequest = SearchPapersRequest;
 type research_SearchPapersResponse = SearchPapersResponse;
 type research_VerifyClaimRequest = VerifyClaimRequest;
 type research_VerifyClaimResponse = VerifyClaimResponse;
 declare namespace research {
-  export type { research_ContradictionDto as ContradictionDto, research_CreateResearchSessionRequest as CreateResearchSessionRequest, research_CreateResearchSessionResponse as CreateResearchSessionResponse, research_EvidenceItemSummaryDto as EvidenceItemSummaryDto, research_IngestPaperRequest as IngestPaperRequest, research_IngestPaperResponse as IngestPaperResponse, research_KnowledgeGapDto as KnowledgeGapDto, research_ListResearchSessionsResponse as ListResearchSessionsResponse, research_PaperMetadataDto as PaperMetadataDto, research_PaperSearchResultDto as PaperSearchResultDto, research_PaperSource as PaperSource, research_ProvenanceStepDto as ProvenanceStepDto, research_ReportVerificationDto as ReportVerificationDto, research_ResearchContradictionsResponse as ResearchContradictionsResponse, research_ResearchCycleResponse as ResearchCycleResponse, research_ResearchCycleResultDto as ResearchCycleResultDto, research_ResearchFindingDto as ResearchFindingDto, research_ResearchFindingsResponse as ResearchFindingsResponse, research_ResearchGapsResponse as ResearchGapsResponse, research_ResearchReportResponse as ResearchReportResponse, research_ResearchSessionResponse as ResearchSessionResponse, research_ResearchSessionStatusDto as ResearchSessionStatusDto, research_ResearchSessionSummaryDto as ResearchSessionSummaryDto, research_ResearchStatisticsDto as ResearchStatisticsDto, research_RunResearchCycleRequest as RunResearchCycleRequest, research_SearchPapersRequest as SearchPapersRequest, research_SearchPapersResponse as SearchPapersResponse, research_VerifyClaimRequest as VerifyClaimRequest, research_VerifyClaimResponse as VerifyClaimResponse };
+  export type { research_ContradictionDto as ContradictionDto, research_ContradictionResolutionDto as ContradictionResolutionDto, research_CreateResearchSessionRequest as CreateResearchSessionRequest, research_CreateResearchSessionResponse as CreateResearchSessionResponse, research_EvidenceItemSummaryDto as EvidenceItemSummaryDto, research_IngestPaperRequest as IngestPaperRequest, research_IngestPaperResponse as IngestPaperResponse, research_KnowledgeGapDto as KnowledgeGapDto, research_ListResearchSessionsResponse as ListResearchSessionsResponse, research_PaperMetadataDto as PaperMetadataDto, research_PaperRefDto as PaperRefDto, research_PaperSearchResultDto as PaperSearchResultDto, research_PaperSource as PaperSource, research_ProvenanceStepDto as ProvenanceStepDto, research_ReportVerificationDto as ReportVerificationDto, research_ResearchContradictionsResponse as ResearchContradictionsResponse, research_ResearchCycleResponse as ResearchCycleResponse, research_ResearchCycleResultDto as ResearchCycleResultDto, research_ResearchFindingDto as ResearchFindingDto, research_ResearchFindingsResponse as ResearchFindingsResponse, research_ResearchGapsResponse as ResearchGapsResponse, research_ResearchReportResponse as ResearchReportResponse, research_ResearchSessionResponse as ResearchSessionResponse, research_ResearchSessionStatusDto as ResearchSessionStatusDto, research_ResearchSessionSummaryDto as ResearchSessionSummaryDto, research_ResearchStatisticsDto as ResearchStatisticsDto, research_ResiduatedFeatureDto as ResiduatedFeatureDto, research_ResolutionStrategyDto as ResolutionStrategyDto, research_RunResearchCycleRequest as RunResearchCycleRequest, research_SearchPapersRequest as SearchPapersRequest, research_SearchPapersResponse as SearchPapersResponse, research_VerifyClaimRequest as VerifyClaimRequest, research_VerifyClaimResponse as VerifyClaimResponse };
 }
 
 /**
@@ -57868,6 +58876,36 @@ declare class Compliance<SecurityDataType = unknown> {
      * @secure
      */
     captureSnapshot: (data: CaptureSnapshotRequest$1, params?: RequestParams) => Promise<HttpResponse<PredictionSnapshot$1, any>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name CreateDsr
+     * @summary File a GDPR data subject request
+     * @request POST:/api/v1/dsr
+     * @secure
+     */
+    createDsr: (data: CreateDsrRequest, params?: RequestParams) => Promise<HttpResponse<DsrRecordResponse, void>>;
+    /**
+     * @description **Dry run by default.** An exact match on an identifying feature is the only deterministic way to resolve a person to terms, but exactness is not uniqueness — two people share a name. Erasing on a bare match would silently destroy a homonym's data, and erasure is irreversible, so the plan has to be inspectable before it runs. Pass `confirm: true` once the match has been reviewed.
+     *
+     * @tags compliance
+     * @name EraseSubject
+     * @summary Plan or execute erasure of a data subject's terms
+     * @request POST:/api/v1/dsr/{id}/erase
+     * @secure
+     */
+    eraseSubject: (id: string, data: SubjectErasureRequest, params?: RequestParams) => Promise<HttpResponse<SubjectErasureReport, void>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name GetDsr
+     * @summary Read a data subject request
+     * @request GET:/api/v1/dsr/{id}
+     * @secure
+     */
+    getDsr: (id: string, params?: RequestParams) => Promise<HttpResponse<DsrRecordResponse, void>>;
     /**
      * No description
      *
@@ -57918,12 +58956,22 @@ declare class Compliance<SecurityDataType = unknown> {
          */
         since?: string | null;
         /** Sort field. Defaults to `timestamp`. */
-        sort_by?: any;
+        sort_by?: AuditSortField$1;
         /** Sort direction. Defaults to `desc` (most-recent-first). */
-        sort_order?: any;
+        sort_order?: AuditSortOrder$1;
         /** Inclusive upper bound on `timestamp` (RFC 3339). */
         until?: string | null;
     }, params?: RequestParams) => Promise<HttpResponse<AuditPage$1, void>>;
+    /**
+     * No description
+     *
+     * @tags compliance
+     * @name ListDsr
+     * @summary List a data subject's requests
+     * @request GET:/api/v1/dsr
+     * @secure
+     */
+    listDsr: (params?: RequestParams) => Promise<HttpResponse<DsrRecordResponse[], any>>;
     /**
      * No description
      *
@@ -60187,6 +61235,16 @@ declare class OntologyBridge<SecurityDataType = unknown> {
      * @secure
      */
     bulkBindSorts: (data: BulkBindSortsRequest$1, params?: RequestParams) => Promise<HttpResponse<BulkBindSortsResponse$1, any>>;
+    /**
+     * @description The gap this closes (#133): the engine could lower OSFQL to a source's native language and could execute native queries, and the two were never reachable together over HTTP. `POST /api/v1/osfql` runs against the knowledge base and never consults a binding; `POST /api/v1/ontology/transpile` emits the query text and stops. A `transpile`-mode source — which deliberately ingests nothing — therefore had no way to be queried at all, and asking about its data returned an empty result indistinguishable from a broken connector. The dialect is derived from the source's type, never taken from the caller: the binding says which source answers for the sort, and that source's type is the only dialect that could run. Letting a caller name one would let them ask for Cypher against Postgres. The emitted query is returned with the rows. Transpile mode's claim is that OSFQL becomes a native query against the operator's own database; returning only rows leaves that unverifiable.
+     *
+     * @tags ontology_bridge
+     * @name ExecuteTranspiled
+     * @summary Transpile an OSFQL MATCH and execute it on the source it is bound to.
+     * @request POST:/api/v1/ontology/query
+     * @secure
+     */
+    executeTranspiled: (data: ExecuteTranspiledRequest, params?: RequestParams) => Promise<HttpResponse<ExecuteTranspiledResponse, void>>;
     /**
      * @description Produces query tools, write tools, and inference tools from the current sort hierarchy and SQL bindings, along with a system prompt suitable for grounding an LLM.
      *
@@ -60228,7 +61286,7 @@ declare class OntologyBridge<SecurityDataType = unknown> {
      */
     listBindings: (params?: RequestParams) => Promise<HttpResponse<ListBindingsResponse$1, any>>;
     /**
-     * @description Parses the OSFQL query, compiles it, and transpiles the first `ScanBySort` operation to SQL using the current sort-table bindings.
+     * @description Parses the OSFQL query, compiles it, and transpiles EVERY `ScanBySort` operation into one statement using the current sort-table bindings — a JOIN for the SQL dialects, a multi-pattern MATCH for Cypher. A plan operation that is not a scan is refused by name rather than dropped: `fully_transpilable` is what a caller checks to decide whether the emitted text is the whole question, and it reported `true` for a query half of which was never emitted (#134).
      *
      * @tags ontology_bridge
      * @name Transpile
@@ -69433,6 +70491,16 @@ declare class Speakers<SecurityDataType = unknown> {
      * @secure
      */
     enrollSpeaker: (data: EnrollSpeakerRequest$1, params?: RequestParams) => Promise<HttpResponse<EnrollSpeakerResponse$1, void>>;
+    /**
+     * @description POST /api/v1/speakers/identify
+     *
+     * @tags speakers
+     * @name IdentifySpeakers
+     * @summary Identify which enrolled voices speak in a piece of audio — no transcript.
+     * @request POST:/api/v1/speakers/identify
+     * @secure
+     */
+    identifySpeakers: (data: IdentifySpeakersRequest, params?: RequestParams) => Promise<HttpResponse<IdentifySpeakersResponse, void>>;
     /**
      * @description GET /api/v1/speakers
      *
@@ -70147,6 +71215,148 @@ declare class ConnectorsClient {
     oauthCallback(name: string, query?: OAuthCallbackQuery): Promise<Response>;
 }
 
+declare class Embeddings<SecurityDataType = unknown> {
+    http: HttpClient<SecurityDataType>;
+    constructor(http: HttpClient<SecurityDataType>);
+    /**
+     * @description POST /api/v1/embeddings/rank
+     *
+     * @tags embeddings
+     * @name RankEmbeddings
+     * @summary Score every candidate against the query by embedding cosine similarity.
+     * @request POST:/api/v1/embeddings/rank
+     * @secure
+     */
+    rankEmbeddings: (data: EmbeddingRankRequest$1, params?: RequestParams) => Promise<HttpResponse<EmbeddingRankResponse$1, void>>;
+}
+
+/**
+ * Embedding-space ranking — `POST /api/v1/embeddings/rank`.
+ *
+ * Scores candidate texts against a query by cosine similarity in the
+ * deployment's shared sentence-embedding space. The endpoint never reorders and
+ * never truncates: it reports one similarity per candidate, in request order,
+ * and leaves the ranking policy to the caller.
+ *
+ * Distinct from the RAG search in `types/rag.ts` (which retrieves from the
+ * knowledge base) — nothing here reads or writes the KB.
+ *
+ * @module
+ */
+/** Body of `POST /api/v1/embeddings/rank` — one query, and the texts to score against it. */
+interface EmbeddingRankRequest {
+    /**
+     * Candidate texts, scored in place — the response is index-aligned with this
+     * list, so the caller can zip the scores back onto whatever it retrieved.
+     *
+     * An empty list is valid and yields an empty score list. The backend caps the
+     * list at 512 candidates and answers `400` above that; rank in pages instead.
+     * A blank candidate is not an error — it keeps its slot and scores `0`.
+     */
+    candidates: string[];
+    /**
+     * The text every candidate is scored against. Must be non-blank
+     * (the backend answers `400` otherwise).
+     *
+     * Capped at 8192 **characters**, as is each candidate; longer text is a `400`.
+     */
+    query: string;
+}
+/** Response of `POST /api/v1/embeddings/rank`. */
+interface EmbeddingRankResponse {
+    /**
+     * Cosine similarity in `[-1, 1]`, same length and same order as the request's
+     * `candidates` — index `i` scores `candidates[i]`.
+     *
+     * Higher is more similar. A candidate with no scoreable text (blank or
+     * whitespace-only) scores `0`, which is the same value an orthogonal candidate
+     * gets: absence of signal, not evidence of dissimilarity.
+     */
+    scores: number[];
+}
+
+type embeddings_EmbeddingRankRequest = EmbeddingRankRequest;
+type embeddings_EmbeddingRankResponse = EmbeddingRankResponse;
+declare namespace embeddings {
+  export type { embeddings_EmbeddingRankRequest as EmbeddingRankRequest, embeddings_EmbeddingRankResponse as EmbeddingRankResponse };
+}
+
+/**
+ * Resource client for embedding-space ranking
+ * (`POST /api/v1/embeddings/rank`).
+ *
+ * @remarks
+ * Scores candidate texts against a query by cosine similarity in the
+ * deployment's shared sentence-embedding space — the same embedder the backend
+ * already loads, so a caller does not have to ship a second sentence
+ * transformer into its own process just to choose which of N retrieved items to
+ * spend an expensive step on.
+ *
+ * The endpoint is a pure function of the request: it reads no tenant data,
+ * writes nothing, and never reorders or truncates. It reports a similarity per
+ * candidate and stops there; the ranking policy stays with the caller.
+ *
+ * Uses the snake_case wire format (every field here happens to be a single
+ * word); no value serialization (`ValueDto` / `FeatureValueDto`) is involved.
+ *
+ * Delegates to the generated `Embeddings` route class for the type-safe HTTP call.
+ */
+declare class EmbeddingsClient {
+    /** @internal */
+    private readonly api;
+    /** @internal */
+    constructor(api: Embeddings);
+    /**
+     * Score every candidate against the query by embedding cosine similarity.
+     *
+     * @param request - The query and the candidate texts to score against it.
+     * @returns `scores` — one cosine similarity in `[-1, 1]` per candidate,
+     *   **index-aligned with `request.candidates`** (index `i` scores
+     *   `candidates[i]`) and the same length, so the scores can be zipped straight
+     *   back onto whatever was retrieved. Higher is more similar; a candidate
+     *   whose text is blank scores `0`.
+     * @throws {BadRequestError} `400` — the query is blank, the candidate list is
+     *   over the backend's 512-candidate cap, or the query / a candidate is over
+     *   8192 characters.
+     * @throws {ApiError} `503` when the deployment has **no embedding backend
+     *   configured** (or its embedder is unreachable / misconfigured). The SDK
+     *   surfaces every 5xx as an `InternalServerError`; read its `status` to tell
+     *   `503` (no embedder) from `500` (ranking failed).
+     *
+     * @remarks
+     * Distinguish "no embedder" from "no similarity": a deployment without an
+     * embedding backend answers `503` rather than a fabricated score, precisely so
+     * a caller cannot mistake it for "everything scored 0" and silently rank by
+     * noise. The documented fallback on a `503` is to keep the source order.
+     *
+     * An empty `candidates` list is valid, not an error: it answers `200` with an
+     * empty `scores` array, so a caller that retrieved nothing still gets a
+     * well-formed, index-aligned response.
+     *
+     * A `0` score is absence of signal, not evidence of dissimilarity — it is also
+     * what an orthogonal candidate and a blank candidate both receive.
+     *
+     * @example
+     * ```typescript
+     * const retrieved = [
+     *   { id: 'doc-1', text: 'Chaperones assist protein folding in the cytosol.' },
+     *   { id: 'doc-2', text: 'Quarterly revenue rose 12% year over year.' },
+     * ];
+     *
+     * const { scores } = await client.embeddings.rank({
+     *   query: 'how proteins fold',
+     *   candidates: retrieved.map((doc) => doc.text),
+     * });
+     *
+     * // Scores are index-aligned — zip them back onto what was retrieved.
+     * const ranked = retrieved
+     *   .map((doc, i) => ({ doc, score: scores[i] }))
+     *   .sort((a, b) => b.score - a.score);
+     * ```
+     */
+    rank(request: EmbeddingRankRequest): Promise<EmbeddingRankResponse>;
+}
+
 /** Core knowledge base operations — types, records, rules, functions, constraints, and queries. */
 interface CoreGroup {
     readonly types: SortsClient;
@@ -70438,6 +71648,8 @@ declare class ReasoningLayerClient {
     readonly speech: SpeechClient;
     /** External data connectors — register / list / remove / connect / disconnect + OAuth callback. */
     readonly connectors: ConnectorsClient;
+    /** Embedding-space ranking — cosine score per candidate against a query, index-aligned. */
+    readonly embeddings: EmbeddingsClient;
     private _core?;
     private _ai?;
     private _reasoning?;
@@ -71912,4 +73124,4 @@ declare function toUntaggedFeatures(features: PlainFeatureMap): Record<string, F
  */
 declare function toTermInputDto(input: PsiTermInput | TermInputDto): TermInputDto;
 
-export { ANY_ROLE, actionReviews as ActionReviews, actions as Actions, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, agui as Agui, type AguiContextItem, type AguiEvent, type AguiFunctionCall, type AguiMessage, type AguiRole, type AguiRunOptions, type AguiTool, type AguiToolCall, type AiGroup, type AlcConcept, analysis as Analysis, type AnalysisGroup, anonymization as Anonymization, ApiError, type ApiResponse, type ArithmeticOp, type AuthConfig, AuthenticationError, authz as Authz, type AuthzAction, type AuthzDryRunRequest, type AuthzDryRunResponse, type AuthzEffect, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, type CascadeOptions, type CatalogPage, causal as Causal, type CertificateDetail, chase as Chase, type ChaseArgDto, type ChaseAtomDto, type ChaseRunRequest, type ChaseRunResponse, type CheckDocumentRequest, type CheckDocumentResponse, type CheckFinding, type CheckSummary, type ClaimAssessment, type ClaimCitation, type ClaimSubtype, type ClaimVerdict, type ClassifyEdgesInput, type ClassifyEdgesVars, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, type CognitiveStrategyDto, coherence as Coherence, type CoherenceAnalyzeRequest, type CoherenceAnalyzeResponse, collections as Collections, communities as Communities, type CompareDocumentsRequest, type ComparisonOp, compliance as Compliance, complianceMarkings as ComplianceMarkings, conformal as Conformal, conformance as Conformance, type ConformanceCheckResponse, type ConformanceRepairResponse, type ConformanceRequest, connectors as Connectors, type ConstrainedPlainVar, Constraint, ConstraintViolationError, constraints as Constraints, control as Control, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTurnsResponse, type CoreGroup, corpus as Corpus, type CorpusBridgesRequest, type CorpusBridgesResponse, type CorpusCommunitiesRequest, type CorpusCommunitiesResponse, type CorpusCrossCuttingRequest, type CorpusCrossCuttingResponse, type CorpusScope, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateSortRequest, type CreateTermRequest, type CtlFormula, dl as DL, type DataGroup, demo as Demo, discovery as Discovery, type DlSatisfiableRequest, type DlSatisfiableResponse, type DlSubsumesRequest, type DlSubsumesResponse, documentCheck as DocumentCheck, documents as Documents, type EqLiteralDto, type EqualityAtomDto, type ErrorResponse$1 as ErrorResponse, execution as Execution, extract as Extract, feasibility as Feasibility, type FeatureInputValueDto, type FeatureValueDto, type FindingKind, type FindingSeverity, Flow, type FlowProblem as FlowBuilderProblem, type FlowEdgeInput, type FlowEdgeOptions, flowNetworks as FlowNetworks, type FlowNode, type FlowProblemInputBase, type FocusEntryDto, ForbiddenError, forecast as Forecast, type ForecastDomain, type ForecastDomainsResponse, type ForecastEntityInput, type ForecastRequest, type ForecastResponse, type ForwardChainRequest, type ForwardChainResponse, functions as Functions, fuzzy as Fuzzy, FuzzyShape, type FuzzyShapeDto, generation as Generation, type GlbRequest, type GlbResponse, type GraphSparqlQueryRequest, type GraphSparqlResults, guardrail as Guardrail, type GuardrailReport, type GuardrailRequest, type GuardrailSummary, health as Health, homoiconic as Homoiconic, ilp as ILP, imageExtraction as ImageExtraction, inference as Inference, type IngestPaperRequest, type IngestPaperResponse, ingestion as Ingestion, IngestionFailedError, IngestionSession, type IngestionSyncOptions, type InlineDocument, type InstallList, type InstallPluginRequest, type InstallPluginResponse, type InstallState, type InstallSummary, type Interceptor, InternalServerError, type JsonValue$1 as JsonValue, type KripkeState, type KripkeTransition, LP, ltn as LTN, type ListCatalogParams, type ListConversationsResponse, type ListInstallsParams, type ListResearchSessionsResponse, type LtnInstance, type LtnQueryRequest, type LtnQueryResponse, type LtnRefuteRequest, type LtnRefuteResponse, type LtnRule, type LtnTrainRequest, type LtnTrainResponse, type LubRequest, type LubResponse, marketplace as Marketplace, type MarketplaceScope, type MaxFlowInput, type MaxFlowVars, type MinCostMaxFlowInput, type MinCostMaxFlowVars, type MinCutInput, type MinCutVars, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, ontologyAlignment as OntologyAlignment, ontologyBridge as OntologyBridge, ontologyExport as OntologyExport, type OntologyExportDocument, type OntologyExportFormat, type OntologyExportOptions, ontologyFacade as OntologyFacade, type Operand, operations as Operations, optimize as Optimize, osfDiff as OsfDiff, type OsfDiffReport, type OsfDiffRequest, type OsfDiffResponse, type OsfDiffSelector, type OsfDiffSequenceReport, type OsfDiffSequenceRequest, type OsfDiffSequenceResponse, type OsfDiffTemporalRequest, type OsfSearchRequest, type OsfSearchResponse, osfql as Osfql, type OsfqlRequest, type OsfqlResponse, type OsfqlValue, oversight as Oversight, type PaginationParams, type PaperMetadataDto, type PaperSource, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, type PluginDependency, type PluginDetail, type PluginManifest, type PluginSummary, type PluginVersion, preferences as Preferences, proofEngine as ProofEngine, propertyGraph as PropertyGraph, type PropertyGraphErrorResponse, type PropertyGraphExecuteResponse, type PropertyGraphQueryRequest, type PropertyGraphTranslateResponse, type PropertyGraphValue, type PsiTermDto, type PsiTermInput, type PublishPluginRequest, type PublishPluginResponse, query as Query, rag as RAG, RateLimitError, type RateLimitInfo, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type ReasoningStageDto, type ReasoningTraceDto, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, type ResearchSessionSummaryDto, type ResolvedCoreferenceDto, reviews as Reviews, reward as Reward, row as Row, type RuleAggregatorDto, type RunAgentRequest, SDK_VERSION, sat as Sat, type SatLiteralDto, type SatSolveRequest, type SatSolveResponse, type SatVerdict, scenarios as Scenarios, scheduling as Scheduling, type SearchCatalogRequest, type SearchCatalogResponse, type SearchPapersRequest, type SearchPapersResponse, type SessionGraphDto, type SimpleTgdDto, smt as Smt, type SmtCheckRequest, type SmtCheckResponse, type SmtFunctionApplicationDto, type SmtVerdict, solver as Solver, SortBuilder, type SortDto, type SortInfoDto, sorts as Sorts, sources as Sources, spaces as Spaces, sparql as Sparql, type SparqlAskResults, type SparqlBindingSet, type SparqlEntailmentRegime, type SparqlQueryRequest, type SparqlQueryResults, type SparqlRdfTerm, type SparqlSelectResults, type SparqlTranslation, type SparqlUpdateRequest, type SparqlUpdateTranslation, speakers as Speakers, speech as Speech, statistical as Statistical, streaming as Streaming, synthetic as Synthetic, type SystemGroup, temporal as Temporal, type TemporalModelCheckRequest, type TemporalModelCheckResponse, type TemporalSeriesRequest, type TemporalSeriesResponse, type TemporalSeriesSpec, type TermDto, type TermInputArg, type TermInputDto, type TermListResponse, type TermPatternDto, type TermResponse, type TermSetSelector, terms as Terms, TimeoutError, translation as Translation, type TurnDto, ui as UI, type UpdateTermRequest, type UpgradeInstallRequest, utilities as Utilities, ValidationError, Value, type ValueDto, values as Values, verification as Verification, type VerifyClaimRequest, type VerifyClaimResponse, vision as Vision, visualization as Visualization, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WorkflowGroup, type YankPluginRequest, type YankPluginResponse, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };
+export { ANY_ROLE, actionReviews as ActionReviews, actions as Actions, type AddFactRequest, type AddFactResponse, type AddRuleRequest, type AddRuleResponse, admin as Admin, agui as Agui, type AguiContextItem, type AguiEvent, type AguiFunctionCall, type AguiMessage, type AguiRole, type AguiRunOptions, type AguiTool, type AguiToolCall, type AiGroup, type AlcConcept, analysis as Analysis, type AnalysisGroup, anonymization as Anonymization, ApiError, type ApiResponse, type ArithmeticOp, type AuthConfig, AuthenticationError, authz as Authz, type AuthzAction, type AuthzDryRunRequest, type AuthzDryRunResponse, type AuthzEffect, type BackwardChainRequest, type BackwardChainResponse, BadRequestError, type BulkAddTermsRequest, type BulkAddTermsResponse, type BulkCreateSortsRequest, type BulkCreateSortsResponse, cdl as CDL, type CascadeOptions, type CatalogPage, causal as Causal, type CertificateDetail, chase as Chase, type ChaseArgDto, type ChaseAtomDto, type ChaseRunRequest, type ChaseRunResponse, type CheckDocumentRequest, type CheckDocumentResponse, type CheckFinding, type CheckSummary, type ClaimAssessment, type ClaimCitation, type ClaimSubtype, type ClaimVerdict, type ClassifyEdgesInput, type ClassifyEdgesVars, type ClearTermsResponse, type ClientConfig, cognitive as Cognitive, type CognitiveStrategyDto, coherence as Coherence, type CoherenceAnalyzeRequest, type CoherenceAnalyzeResponse, collections as Collections, communities as Communities, type CompareDocumentsRequest, type ComparisonOp, compliance as Compliance, complianceMarkings as ComplianceMarkings, conformal as Conformal, conformance as Conformance, type ConformanceCheckResponse, type ConformanceRepairResponse, type ConformanceRequest, connectors as Connectors, type ConstrainedPlainVar, Constraint, ConstraintViolationError, constraints as Constraints, control as Control, conversation as Conversation, type ConversationMessageRequest, type ConversationMessageResponse, type ConversationSummaryDto, type ConversationTurnsResponse, type CoreGroup, corpus as Corpus, type CorpusBridgesRequest, type CorpusBridgesResponse, type CorpusCommunitiesRequest, type CorpusCommunitiesResponse, type CorpusCrossCuttingRequest, type CorpusCrossCuttingResponse, type CorpusScope, type CreateResearchSessionRequest, type CreateResearchSessionResponse, type CreateSortRequest, type CreateTermRequest, type CtlFormula, dl as DL, type DataGroup, demo as Demo, discovery as Discovery, type DlSatisfiableRequest, type DlSatisfiableResponse, type DlSubsumesRequest, type DlSubsumesResponse, documentCheck as DocumentCheck, documents as Documents, embeddings as Embeddings, type EqLiteralDto, type EqualityAtomDto, type ErrorResponse$1 as ErrorResponse, execution as Execution, extract as Extract, feasibility as Feasibility, type FeatureInputValueDto, type FeatureValueDto, type FindingKind, type FindingSeverity, Flow, type FlowProblem as FlowBuilderProblem, type FlowEdgeInput, type FlowEdgeOptions, flowNetworks as FlowNetworks, type FlowNode, type FlowProblemInputBase, type FocusEntryDto, ForbiddenError, forecast as Forecast, type ForecastDomain, type ForecastDomainsResponse, type ForecastEntityInput, type ForecastRequest, type ForecastResponse, type ForwardChainRequest, type ForwardChainResponse, functions as Functions, fuzzy as Fuzzy, FuzzyShape, type FuzzyShapeDto, generation as Generation, type GlbRequest, type GlbResponse, type GraphSparqlQueryRequest, type GraphSparqlResults, guardrail as Guardrail, type GuardrailReport, type GuardrailRequest, type GuardrailSummary, health as Health, homoiconic as Homoiconic, ilp as ILP, imageExtraction as ImageExtraction, inference as Inference, type IngestPaperRequest, type IngestPaperResponse, ingestion as Ingestion, IngestionFailedError, IngestionSession, type IngestionSyncOptions, type InlineDocument, type InstallList, type InstallPluginRequest, type InstallPluginResponse, type InstallState, type InstallSummary, type Interceptor, InternalServerError, type JsonValue$1 as JsonValue, type KripkeState, type KripkeTransition, LP, ltn as LTN, type ListCatalogParams, type ListConversationsResponse, type ListInstallsParams, type ListResearchSessionsResponse, type LtnInstance, type LtnQueryRequest, type LtnQueryResponse, type LtnRefuteRequest, type LtnRefuteResponse, type LtnRule, type LtnTrainRequest, type LtnTrainResponse, type LubRequest, type LubResponse, marketplace as Marketplace, type MarketplaceScope, type MaxFlowInput, type MaxFlowVars, type MinCostMaxFlowInput, type MinCostMaxFlowVars, type MinCutInput, type MinCutVars, namespaces as Namespaces, NetworkError, neuroSymbolic as NeuroSymbolic, NotFoundError, ontology as Ontology, ontologyAlignment as OntologyAlignment, ontologyBridge as OntologyBridge, ontologyExport as OntologyExport, type OntologyExportDocument, type OntologyExportFormat, type OntologyExportOptions, ontologyFacade as OntologyFacade, type Operand, operations as Operations, optimize as Optimize, osfDiff as OsfDiff, type OsfDiffReport, type OsfDiffRequest, type OsfDiffResponse, type OsfDiffSelector, type OsfDiffSequenceReport, type OsfDiffSequenceRequest, type OsfDiffSequenceResponse, type OsfDiffTemporalRequest, type OsfSearchRequest, type OsfSearchResponse, osfql as Osfql, type OsfqlRequest, type OsfqlResponse, type OsfqlValue, oversight as Oversight, type PaginationParams, type PaperMetadataDto, type PaperSource, type PlainFeatureMap, type PlainFeatureValue, plainValues as PlainValues, type PluginDependency, type PluginDetail, type PluginManifest, type PluginSummary, type PluginVersion, preferences as Preferences, proofEngine as ProofEngine, propertyGraph as PropertyGraph, type PropertyGraphErrorResponse, type PropertyGraphExecuteResponse, type PropertyGraphQueryRequest, type PropertyGraphTranslateResponse, type PropertyGraphValue, type PsiTermDto, type PsiTermInput, type PublishPluginRequest, type PublishPluginResponse, query as Query, rag as RAG, RateLimitError, type RateLimitInfo, reasoning as Reasoning, type ReasoningGroup, ReasoningLayerClient, ReasoningLayerError, type ReasoningStageDto, type ReasoningTraceDto, type RequestOptions, research as Research, type ResearchContradictionsResponse, type ResearchCycleResponse, type ResearchFindingsResponse, type ResearchGapsResponse, type ResearchReportResponse, type ResearchSessionResponse, type ResearchSessionSummaryDto, type ResolvedCoreferenceDto, reviews as Reviews, reward as Reward, row as Row, type RuleAggregatorDto, type RunAgentRequest, SDK_VERSION, sat as Sat, type SatLiteralDto, type SatSolveRequest, type SatSolveResponse, type SatVerdict, scenarios as Scenarios, scheduling as Scheduling, type SearchCatalogRequest, type SearchCatalogResponse, type SearchPapersRequest, type SearchPapersResponse, type SessionGraphDto, type SimpleTgdDto, smt as Smt, type SmtCheckRequest, type SmtCheckResponse, type SmtFunctionApplicationDto, type SmtVerdict, solver as Solver, SortBuilder, type SortDto, type SortInfoDto, sorts as Sorts, sources as Sources, spaces as Spaces, sparql as Sparql, type SparqlAskResults, type SparqlBindingSet, type SparqlEntailmentRegime, type SparqlQueryRequest, type SparqlQueryResults, type SparqlRdfTerm, type SparqlSelectResults, type SparqlTranslation, type SparqlUpdateRequest, type SparqlUpdateTranslation, speakers as Speakers, speech as Speech, statistical as Statistical, streaming as Streaming, synthetic as Synthetic, type SystemGroup, temporal as Temporal, type TemporalModelCheckRequest, type TemporalModelCheckResponse, type TemporalSeriesRequest, type TemporalSeriesResponse, type TemporalSeriesSpec, type TermDto, type TermInputArg, type TermInputDto, type TermListResponse, type TermPatternDto, type TermResponse, type TermSetSelector, terms as Terms, TimeoutError, translation as Translation, type TurnDto, ui as UI, type UpdateTermRequest, type UpgradeInstallRequest, utilities as Utilities, ValidationError, Value, type ValueDto, values as Values, verification as Verification, type VerifyClaimRequest, type VerifyClaimResponse, vision as Vision, visualization as Visualization, WebSocketClient, WebSocketConnection, webhookActions as WebhookActions, type WorkflowGroup, type YankPluginRequest, type YankPluginResponse, allen, constrained, discriminateFeatureValue, guard, isConstrainedPlainVar, isPsiTermInput, isTaggedValueDto, isUuid, psi, toTaggedFeatures, toTaggedValue, toTermInputDto, toUntaggedFeatures, toUntaggedValue };