@kortexya/reasoninglayer 5.1.0 → 6.1.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "5.1.0";
+var SDK_VERSION = "6.1.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -879,6 +879,8 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "filter",
   "initialBindings",
   "initial_bindings",
+  "inputEtags",
+  "input_etags",
   "inputs",
   "interventions",
   "modifiedParams",
@@ -902,11 +904,13 @@ var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
   "sort_names",
   "sources",
   "state",
+  "steps",
   "toolResults",
   "tool_results",
   "topK",
   "top_k",
-  "values"
+  "values",
+  "verdicts"
 ]);
 
 // src/serialization.ts
@@ -2589,6 +2593,57 @@ var Inference = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Aborts the job's task. The proof finishes the step it is on, its result is dropped, and the job reads `cancelled`. A job running on another engine is aborted there at its next heartbeat.
+   *
+   * @tags inference
+   * @name CancelInferenceJob
+   * @summary Cancel a running job.
+   * @request POST:/api/v1/inference/jobs/{id}/cancel
+   * @secure
+   */
+  cancelInferenceJob = (id, params = {}) => this.http.request({
+    path: `/api/v1/inference/jobs/${id}/cancel`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags inference
+   * @name CategoricalInfer
+   * @request POST:/api/v1/inference/categorical
+   * @secure
+   */
+  categoricalInfer = (data, params = {}) => this.http.request({
+    path: `/api/v1/inference/categorical`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags inference
+   * @name CategoricalVerify
+   * @summary Checks reproducibility against current inputs. This grants no authorization to act and does not establish truth of the model's numerical parameters.
+   * @request POST:/api/v1/inference/categorical/verify
+   * @secure
+   */
+  categoricalVerify = (data, params = {}) => this.http.request({
+    path: `/api/v1/inference/categorical/verify`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description This drops the hydrated base facts, the forward-chain `keep_derived` facts and the residuation store, then forgets the hydration flag so the next request reloads the base facts from PostgreSQL. **It does not delete durable data.** The terms are the authority; this is their cache. That makes it the retraction primitive forward chaining otherwise lacks. Chaining is monotonic — delete a `blocks` edge and the derived "A blocks B" survives every later pass, so the KB keeps asserting a relationship the user removed. Clearing and re-chaining rebuilds the closure from the terms that actually exist. # History Until 2026-07-28 this handler enumerated every term in the tenant and deleted it from PostgreSQL, while calling itself "clear facts" and reporting `"Cleared N facts/rules"`. It is reachable with an ordinary tenant credential — unlike `/api/v1/admin/clear-tenant/{tenant_id}`, which gateways block — so a caller reading the name, the path or the response body had no way to know it was a tenant wipe. It destroyed a live tenant that way. Use `DELETE /api/v1/terms/{term_id}` to delete a term, and the admin route to wipe a tenant; deleting durable data must not be something an endpoint does as a side effect of its name. # Authorization Requires X-Tenant-Id header, and the path tenant must match it.
    *
@@ -2657,6 +2712,21 @@ var Inference = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags inference
+   * @name DeleteInferenceJob
+   * @summary Forget a job.
+   * @request DELETE:/api/v1/inference/jobs/{id}
+   * @secure
+   */
+  deleteInferenceJob = (id, params = {}) => this.http.request({
+    path: `/api/v1/inference/jobs/${id}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
   /**
    * @description # The disposition is the caller's `?derivations=refuse` (the default) refuses while the rule still supports materialized conclusions and says how many; `?derivations=retract` withdraws them with it and reports the counts. A delete that silently drops derivations is as wrong as one that silently keeps them, so neither is the unnamed default. # Authorization Requires `X-Tenant-Id`. Runs the same delete guard as `DELETE /api/v1/terms/{id}` — a rule is a policy-relevant object, and withdrawing one changes what the engine will conclude. Honours `If-Match` against the conclusion's content ETag — the tag [`rule_content_tag`] publishes on the rule routes (#473) — and requires it under `OSFKB_REQUIRE_IF_MATCH=1`. Every request is captured by the audit middleware.
    *
@@ -2779,6 +2849,22 @@ var Inference = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags inference
+   * @name GetInferenceJob
+   * @summary A job, with its result once it completed.
+   * @request GET:/api/v1/inference/jobs/{id}
+   * @secure
+   */
+  getInferenceJob = (id, params = {}) => this.http.request({
+    path: `/api/v1/inference/jobs/${id}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns the sort IDs of built-in meta sorts (guard_constraint, variable, etc.) Clients need these IDs to create terms using built-in sorts. # TRUE HOMOICONICITY In Aït-Kaci's vision, everything is referenced by ID, not by name. This endpoint provides the IDs clients need for built-in sorts. # Authorization Requires X-Tenant-Id header.
    *
@@ -2827,6 +2913,22 @@ var Inference = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags inference
+   * @name ListInferenceJobs
+   * @summary The tenant's jobs, newest first.
+   * @request GET:/api/v1/inference/jobs
+   * @secure
+   */
+  listInferenceJobs = (params = {}) => this.http.request({
+    path: `/api/v1/inference/jobs`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description # TRUE HOMOICONIC API Uses LiteralInputDto with TermInputDto for literals. Response uses homoiconic SolutionDto. # Authorization Requires X-Tenant-Id header.
    *
@@ -2881,6 +2983,24 @@ var Inference = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Runs a backward-chain, forward-chain, NAF or fuzzy-prove request in the engine and answers at once with a job id. Poll `GET /inference/jobs/{id}` for the result, which is the inline route's response body. The last 100 jobs per tenant are kept: in PostgreSQL when the engine has a database, where a job whose engine stops is resumed by another engine, which runs its request again (at most 3 runs); in the process otherwise.
+   *
+   * @tags inference
+   * @name SubmitInferenceJob
+   * @summary Submit an inference request to run in the background.
+   * @request POST:/api/v1/inference/jobs
+   * @secure
+   */
+  submitInferenceJob = (data, params = {}) => this.http.request({
+    path: `/api/v1/inference/jobs`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description In OSF/LIFE terms, the orchestrator pushes the conclusion gate and each antecedent gate toward the dual-weighted satisfaction objective `1 − ( w_D · K_D + w_K · K_K )` (paper eq. 4). Each call performs exactly one epoch over the supplied batch — the response carries the per-epoch metrics for that single epoch (multi-epoch aggregation is the caller's responsibility). # Authorization Requires `X-Tenant-Id` header.
    *
@@ -3052,6 +3172,22 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name ExportAgent
+   * @summary Export an agent as a portable bundle.
+   * @request GET:/api/v1/cognitive/agents/{agent_id}/export
+   * @secure
+   */
+  exportAgent = (agentId, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/export`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Reads the persisted, tenant-scoped `ActionReviewConfig` from the registry (hydrating agents first so a restored snapshot's config is visible), or sensible defaults when none has been set. Complements the PUT so the UI's oversight editor can load what's actually stored instead of a local stand-in.
    *
@@ -3162,6 +3298,24 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name ImportAgent
+   * @summary Create a new agent from a bundle.
+   * @request POST:/api/v1/cognitive/agents/import
+   * @secure
+   */
+  importAgent = (data, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/import`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Unlike `provide_feedback` which accepts natural language corrections, this endpoint accepts a structured correction pattern directly as Ψ-term features. This is useful when the client has already parsed the correction.
    *
@@ -3178,6 +3332,23 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The cycles the agent ran over HTTP, newest first: when, how long, completed or failed (with the reason), and the goals achieved and failed and actions executed. The last 200 runs per agent are kept: in PostgreSQL when the engine has a database (a restart keeps them), in the process otherwise.
+   *
+   * @tags cognitive
+   * @name ListAgentRuns
+   * @summary The agent's recent runs.
+   * @request GET:/api/v1/cognitive/agents/{agent_id}/runs
+   * @secure
+   */
+  listAgentRuns = (agentId, query, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}/runs`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Returns each agent's basic BDI state (goals, beliefs, pending status), the same shape as `get_single_agent`. Lazy-hydrates from the database first so agents created by the backend, another device, or another client are included — not just those created in the current process. Tenant is identified by the `X-Tenant-Id` header.
    *
@@ -3354,6 +3525,24 @@ var Cognitive = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags cognitive
+   * @name UpdateAgent
+   * @summary Rename an agent and replace its configuration.
+   * @request PUT:/api/v1/cognitive/agents/{agent_id}
+   * @secure
+   */
+  updateAgent = (agentId, data, params = {}) => this.http.request({
+    path: `/api/v1/cognitive/agents/${agentId}`,
+    method: "PUT",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/CognitiveAgentsEpisodicMemory.ts
@@ -3683,17 +3872,21 @@ var Ingestion = class {
     ...params
   });
   /**
-   * No description
+   * @description Parses the stored file by its name's extension and ingests it exactly as `POST /ingest/document` does: `parse_only` answers the Markdown (200) and keeps the bytes; `?sync=false` enqueues (202); otherwise the document is ingested inline (201). A `sha256` is checked against the whole file first. After an ingest the bytes are removed and the upload reads `ingested`; a failed parse (422) keeps them for a retry.
    *
    * @tags ingestion
-   * @name Chunk
-   * @request PUT:/api/v1/ingest/rdf/uploads/{id}
+   * @name CompleteDocumentUpload
+   * @summary Parse and ingest the uploaded file.
+   * @request POST:/api/v1/ingest/documents/uploads/{id}/complete
+   * @secure
    */
-  chunk = (id, query, data, params = {}) => this.http.request({
-    path: `/api/v1/ingest/rdf/uploads/${id}`,
-    method: "PUT",
+  completeDocumentUpload = (id, data, query, params = {}) => this.http.request({
+    path: `/api/v1/ingest/documents/uploads/${id}/complete`,
+    method: "POST",
     query,
     body: data,
+    secure: true,
+    type: "application/json",
     format: "json",
     ...params
   });
@@ -3701,10 +3894,10 @@ var Ingestion = class {
    * No description
    *
    * @tags ingestion
-   * @name Complete
+   * @name CompleteRdfUpload
    * @request POST:/api/v1/ingest/rdf/uploads/{id}/complete
    */
-  complete = (id, params = {}) => this.http.request({
+  completeRdfUpload = (id, params = {}) => this.http.request({
     path: `/api/v1/ingest/rdf/uploads/${id}/complete`,
     method: "POST",
     format: "json",
@@ -3726,14 +3919,50 @@ var Ingestion = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Opens a resumable upload. PUT the bytes chunk by chunk at `?offset=` (every chunk but the last exactly `chunk_bytes` long), then POST `complete` to parse and ingest the file as `POST /ingest/document` would. Files are kept under OSFKB_DOCUMENT_UPLOAD_DIR (default: the system temp directory).
+   *
+   * @tags ingestion
+   * @name CreateDocumentUpload
+   * @summary Open an upload.
+   * @request POST:/api/v1/ingest/documents/uploads
+   * @secure
+   */
+  createDocumentUpload = (data, params = {}) => this.http.request({
+    path: `/api/v1/ingest/documents/uploads`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description Registers a URL the engine re-crawls every `interval_seconds`, storing what changed through the same path as `POST /ingest/url`. The first refresh falls due after one interval; `POST /ingest/sources/{id}/refresh` runs one at once. With a database the sources are kept in PostgreSQL, survive a restart, and one engine refreshes each due source; without one they are held in the process.
+   *
+   * @tags ingestion
+   * @name CreateIngestSource
+   * @summary Register a source to refresh on an interval.
+   * @request POST:/api/v1/ingest/sources
+   * @secure
+   */
+  createIngestSource = (data, params = {}) => this.http.request({
+    path: `/api/v1/ingest/sources`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
    * @tags ingestion
-   * @name Create
+   * @name CreateRdfUpload
    * @request POST:/api/v1/ingest/rdf/uploads
    */
-  create = (data, params = {}) => this.http.request({
+  createRdfUpload = (data, params = {}) => this.http.request({
     path: `/api/v1/ingest/rdf/uploads`,
     method: "POST",
     body: data,
@@ -3741,6 +3970,21 @@ var Ingestion = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags ingestion
+   * @name DeleteDocumentUpload
+   * @summary Discard an upload and its bytes.
+   * @request DELETE:/api/v1/ingest/documents/uploads/{id}
+   * @secure
+   */
+  deleteDocumentUpload = (id, params = {}) => this.http.request({
+    path: `/api/v1/ingest/documents/uploads/${id}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
   /**
    * @description DELETE /api/v1/ingest/sessions/{session_id} Deletes an ingestion session and all associated progress records. This does NOT delete the ingested entities - only the session tracking data. # Path Parameters - `session_id`: UUID of the session to delete # Headers - `X-Tenant-Id`: Tenant ID for multi-tenancy isolation (required) # Response - 204 No Content on success
    *
@@ -3760,13 +4004,15 @@ var Ingestion = class {
    * No description
    *
    * @tags ingestion
-   * @name Get
-   * @request GET:/api/v1/ingest/rdf/uploads/{id}
+   * @name DeleteIngestSource
+   * @summary Remove a source.
+   * @request DELETE:/api/v1/ingest/sources/{id}
+   * @secure
    */
-  get = (id, params = {}) => this.http.request({
-    path: `/api/v1/ingest/rdf/uploads/${id}`,
-    method: "GET",
-    format: "json",
+  deleteIngestSource = (id, params = {}) => this.http.request({
+    path: `/api/v1/ingest/sources/${id}`,
+    method: "DELETE",
+    secure: true,
     ...params
   });
   /**
@@ -3785,6 +4031,22 @@ var Ingestion = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags ingestion
+   * @name GetDocumentUpload
+   * @summary An upload's progress: `uploaded_bytes` is the offset to resume from.
+   * @request GET:/api/v1/ingest/documents/uploads/{id}
+   * @secure
+   */
+  getDocumentUpload = (id, params = {}) => this.http.request({
+    path: `/api/v1/ingest/documents/uploads/${id}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description GET /api/v1/ingest/sessions/{session_id}/documents/{document_id}/stats Returns the markdown ingestion stats of a specific document. Returns 204 No Content only while the document is still pending or in progress. A failed or cancelled document never gets stats: this route answers 409, and the failure reason is `documents[].error` on `GET /api/v1/ingest/sessions/{session_id}`. An RDF import has no markdown stats either: its receipt is on that same route, and this route answers 404. # Response Codes - 200: Document stats returned - 204: Document is still pending or in progress - 404: Session or document not found, an RDF import, or no stats recorded - 409: Document failed or was cancelled
    *
@@ -3865,6 +4127,19 @@ var Ingestion = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags ingestion
+   * @name GetRdfUpload
+   * @request GET:/api/v1/ingest/rdf/uploads/{id}
+   */
+  getRdfUpload = (id, params = {}) => this.http.request({
+    path: `/api/v1/ingest/rdf/uploads/${id}`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/ingest/audio
    *
@@ -4032,31 +4307,34 @@ var Ingestion = class {
     ...params
   });
   /**
-   * No description
+   * @description Returns paginated list of chunk failures in the dead-letter queue.
    *
    * @tags ingestion
-   * @name List
-   * @request GET:/api/v1/ingest/rdf/uploads
+   * @name ListDlqEntries
+   * @summary List pending DLQ entries for the current tenant.
+   * @request GET:/api/v1/ingest/dlq
+   * @secure
    */
-  list = (params = {}) => this.http.request({
-    path: `/api/v1/ingest/rdf/uploads`,
+  listDlqEntries = (query, params = {}) => this.http.request({
+    path: `/api/v1/ingest/dlq`,
     method: "GET",
+    query,
+    secure: true,
     format: "json",
     ...params
   });
   /**
-   * @description Returns paginated list of chunk failures in the dead-letter queue.
+   * No description
    *
    * @tags ingestion
-   * @name ListDlqEntries
-   * @summary List pending DLQ entries for the current tenant.
-   * @request GET:/api/v1/ingest/dlq
+   * @name ListDocumentUploads
+   * @summary The tenant's uploads, oldest first.
+   * @request GET:/api/v1/ingest/documents/uploads
    * @secure
    */
-  listDlqEntries = (query, params = {}) => this.http.request({
-    path: `/api/v1/ingest/dlq`,
+  listDocumentUploads = (params = {}) => this.http.request({
+    path: `/api/v1/ingest/documents/uploads`,
     method: "GET",
-    query,
     secure: true,
     format: "json",
     ...params
@@ -4097,15 +4375,62 @@ var Ingestion = class {
    * No description
    *
    * @tags ingestion
-   * @name Pause
+   * @name ListIngestSources
+   * @summary List the tenant's sources.
+   * @request GET:/api/v1/ingest/sources
+   * @secure
+   */
+  listIngestSources = (params = {}) => this.http.request({
+    path: `/api/v1/ingest/sources`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags ingestion
+   * @name ListRdfUploads
+   * @request GET:/api/v1/ingest/rdf/uploads
+   */
+  listRdfUploads = (params = {}) => this.http.request({
+    path: `/api/v1/ingest/rdf/uploads`,
+    method: "GET",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags ingestion
+   * @name PauseRdfUpload
    * @request POST:/api/v1/ingest/rdf/uploads/{id}/pause
    */
-  pause = (id, params = {}) => this.http.request({
+  pauseRdfUpload = (id, params = {}) => this.http.request({
     path: `/api/v1/ingest/rdf/uploads/${id}/pause`,
     method: "POST",
     format: "json",
     ...params
   });
+  /**
+   * @description Stores the chunk at `offset`, which must be the next unwritten offset (a multiple of `chunk_bytes`). A chunk already stored may be sent again: it is acknowledged if its bytes match and refused if they differ. The receipt is answered once the bytes are on disk.
+   *
+   * @tags ingestion
+   * @name PutDocumentUploadChunk
+   * @summary Store one chunk.
+   * @request PUT:/api/v1/ingest/documents/uploads/{id}
+   * @secure
+   */
+  putDocumentUploadChunk = (id, query, data, params = {}) => this.http.request({
+    path: `/api/v1/ingest/documents/uploads/${id}`,
+    method: "PUT",
+    query,
+    body: data,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Finds documents stuck in InProgress for longer than the specified timeout and releases them back to Pending for re-processing.
    *
@@ -4124,6 +4449,22 @@ var Ingestion = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags ingestion
+   * @name RefreshIngestSource
+   * @summary Refresh a source now.
+   * @request POST:/api/v1/ingest/sources/{id}/refresh
+   * @secure
+   */
+  refreshIngestSource = (id, params = {}) => this.http.request({
+    path: `/api/v1/ingest/sources/${id}/refresh`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Finds documents in Failed status, resets them and optionally re-enqueues them.
    *
@@ -4209,6 +4550,21 @@ var Ingestion = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags ingestion
+   * @name UploadRdfChunk
+   * @request PUT:/api/v1/ingest/rdf/uploads/{id}
+   */
+  uploadRdfChunk = (id, query, data, params = {}) => this.http.request({
+    path: `/api/v1/ingest/rdf/uploads/${id}`,
+    method: "PUT",
+    query,
+    body: data,
+    format: "json",
+    ...params
+  });
   /**
    * @description URL ingestion needs no configuration and is always available; the report carries its limits. Web search is available only when a search provider is registered (`WEB_SEARCH_API_URL`); otherwise `available` is `false`, `unavailable_reason` says what to set, and both `POST /api/v1/web/search` (503 `web_search_not_configured`) and the `web_search` agent action answer "not configured".
    *
@@ -4935,7 +5291,7 @@ var Copy = class {
    *
    * @tags copy
    * @name BatchCopy
-   * @summary Batch copy terms POST /api/v1/copy/batch
+   * @summary Copy several terms; each copy succeeds or fails on its own POST /api/v1/copy/batch
    * @request POST:/api/v1/copy/batch
    * @secure
    */
@@ -4953,7 +5309,7 @@ var Copy = class {
    *
    * @tags copy
    * @name CopyTerm
-   * @summary Copy a term with specified semantics POST /api/v1/copy/term
+   * @summary Copy a term into a new stored term POST /api/v1/copy/term
    * @request POST:/api/v1/copy/term
    * @secure
    */
@@ -4971,7 +5327,7 @@ var Copy = class {
    *
    * @tags copy
    * @name DeepCopy
-   * @summary Deep copy a term with cycle detection POST /api/v1/copy/deep
+   * @summary Copy a term and the terms it references POST /api/v1/copy/deep
    * @request POST:/api/v1/copy/deep
    * @secure
    */
@@ -5142,6 +5498,21 @@ var Collections = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * @description The term must exist for the caller's tenant (404 otherwise), and so must the collection. Membership only scopes the term: nothing about it changes.
+   *
+   * @tags collections
+   * @name AddExistingTermToCollection
+   * @summary Add an existing term to a collection.
+   * @request PUT:/api/v1/collections/{id}/terms/{term_id}
+   * @secure
+   */
+  addExistingTermToCollection = (id, termId, params = {}) => this.http.request({
+    path: `/api/v1/collections/${id}/terms/${termId}`,
+    method: "PUT",
+    secure: true,
+    ...params
+  });
   /**
    * @description # Authorization Requires X-Namespace-Id header. The namespace_id field in the request body is ignored.
    *
@@ -5375,6 +5746,21 @@ var Collections = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags collections
+   * @name RemoveTermFromCollection
+   * @summary Remove a term from a collection. The term itself is not deleted.
+   * @request DELETE:/api/v1/collections/{id}/terms/{term_id}
+   * @secure
+   */
+  removeTermFromCollection = (id, termId, params = {}) => this.http.request({
+    path: `/api/v1/collections/${id}/terms/${termId}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
   /**
    * No description
    *
@@ -6097,6 +6483,24 @@ var Causal = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags causal
+   * @name EstimateCateHandler
+   * @summary Estimate how a treatment's effect varies with the covariates (DR-learner).
+   * @request POST:/api/v1/causal/cate
+   * @secure
+   */
+  estimateCateHandler = (data, params = {}) => this.http.request({
+    path: `/api/v1/causal/cate`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -6133,6 +6537,24 @@ var Causal = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags causal
+   * @name EstimateLateHandler
+   * @summary Estimate the effect of a treatment on compliers through a binary instrument.
+   * @request POST:/api/v1/causal/late
+   * @secure
+   */
+  estimateLateHandler = (data, params = {}) => this.http.request({
+    path: `/api/v1/causal/late`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -6187,6 +6609,24 @@ var Causal = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Fits a triangular-kernel local linear regression on each side of the cutoff and reports the difference of the two intercepts. Sharp design only: treatment is exactly `running >= cutoff`.
+   *
+   * @tags causal
+   * @name EstimateRegressionDiscontinuity
+   * @summary Estimate the effect at a cutoff by sharp regression discontinuity.
+   * @request POST:/api/v1/causal/rdd
+   * @secure
+   */
+  estimateRegressionDiscontinuity = (data, params = {}) => this.http.request({
+    path: `/api/v1/causal/rdd`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -6205,6 +6645,42 @@ var Causal = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags causal
+   * @name EstimateSurvivalEffect
+   * @summary Estimate the survival difference at a horizon from censored time-to-event units.
+   * @request POST:/api/v1/causal/survival
+   * @secure
+   */
+  estimateSurvivalEffect = (data, params = {}) => this.http.request({
+    path: `/api/v1/causal/survival`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags causal
+   * @name EstimateSyntheticControl
+   * @summary Estimate a treated unit's effect against a synthetic counterfactual.
+   * @request POST:/api/v1/causal/synthetic-control
+   * @secure
+   */
+  estimateSyntheticControl = (data, params = {}) => this.http.request({
+    path: `/api/v1/causal/synthetic-control`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description The REAL three-step runs (exact abduction over the shared noise, surgery, forward prediction — `RuleScm` enumeration), with `causes(x, y, c)` read as an independent `Bernoulli(c)` transmission and effects as ORs of transmitted causes. Answers are exact RELATIVE TO that declared parameterization (the `method` field says so); unobserved roots carry flagged `Bernoulli(½)` priors reported in `assumed_root_priors`. Non-boolean variables, evidence impossible under the no-leak semantics, and oversized noise spaces refuse with the reason — declare a full SCM via `POST /api/v1/causal/counterfactual/scm` for richer mechanisms.
    *
@@ -6916,6 +7392,24 @@ var Ilp = class {
     format: "json",
     ...params
   });
+  /**
+   * @description FOIL: learns Horn clauses for the target relation by sequential covering, growing each clause one body literal at a time by information gain until it covers no negative example. Relations are sorts read through ordered features; the target's terms are the positives. Every returned clause covers no negative example and comes with an OSFQL DERIVE that installs it.
+   *
+   * @tags ilp
+   * @name LearnRelationalRules
+   * @summary Learn rules for a relation from the knowledge base's facts.
+   * @request POST:/api/v1/ilp/learn-rules
+   * @secure
+   */
+  learnRelationalRules = (data, params = {}) => this.http.request({
+    path: `/api/v1/ilp/learn-rules`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description GET /api/v1/ilp/patterns Returns all patterns that have been learned in this session.
    *
@@ -7236,7 +7730,7 @@ var Extraction = class {
     ...params
   });
   /**
-   * @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.
+   * @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 503.
    *
    * @tags extraction
    * @name ExtractEntities
@@ -8059,6 +8553,22 @@ var Reasoning = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags reasoning
+   * @name DisentailmentBatch
+   * @summary Evaluate a batch of exclusions using one tenant store and one overlay. Errors invalidate the whole batch. An unviolated exclusion is not a claim that either operand is true, or that the supplied evidence is complete.
+   * @request POST:/api/v1/reasoning/disentailment/batch
+   */
+  disentailmentBatch = (data, params = {}) => this.http.request({
+    path: `/api/v1/reasoning/disentailment/batch`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @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.
    *
@@ -8177,7 +8687,7 @@ var Reasoning = class {
     ...params
   });
   /**
-   * @description POST /api/v1/reasoning/resource-coordination **CURRENT STATUS**: This endpoint currently only supports 2-way pairwise coordination. **TODO**: Migrate to N-way coordination as defined in the updated DTOs. This is a GENERIC endpoint that works for ANY pairing scenario: - Meals + Wines (food service) - Tasks + Tools (project management) - Outfits + Occasions (fashion) - etc. The system knows nothing about wine or meals - it's purely generic. **Migration needed**: 1. Update to accept `resources: Vec<ResourceSpec>` instead of primary/secondary 2. Implement N-way compatibility algorithm in domain layer 3. Update service layer to handle N resources 4. Return `CoordinatedResourceSet` instead of `PairedResourceDto` 5. See RESOURCE_COORDINATION_EXAMPLES.md for target API design
+   * @description POST /api/v1/reasoning/resource-coordination **CURRENT STATUS**: This endpoint currently only supports 2-way pairwise coordination. **TODO**: Migrate to N-way coordination as defined in the updated DTOs. This is a GENERIC endpoint that works for ANY pairing scenario: - Meals + Wines (food service) - Tasks + Tools (project management) - Outfits + Occasions (fashion) - etc. The system knows nothing about wine or meals - it's purely generic. Two resources without `rules` use the scored pairwise planner. Three or more, or explicit `rules`, are solved as one bundle per selection: a backtracking search for one candidate of each resource that satisfies every rule, no candidate reused across selections.
    *
    * @tags reasoning
    * @name ResourceCoordination
@@ -8495,7 +9005,7 @@ var Control = class {
    *
    * @tags control
    * @name AddSymbol
-   * @summary Add symbol to module POST /api/v1/modules/:name/symbols
+   * @summary Add a symbol to a module POST /api/v1/modules/symbols
    * @request POST:/api/v1/modules/symbols
    * @secure
    */
@@ -8508,186 +9018,6 @@ var Control = class {
     format: "json",
     ...params
   });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name AssignBacktrackable
-   * @summary Backtrackable assignment POST /api/v1/control/assign/backtrackable
-   * @request POST:/api/v1/control/assign/backtrackable
-   * @secure
-   */
-  assignBacktrackable = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/assign/backtrackable`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name AssignGlobal
-   * @summary Global assignment POST /api/v1/control/assign/global
-   * @request POST:/api/v1/control/assign/global
-   * @secure
-   */
-  assignGlobal = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/assign/global`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name ControlCallOnce
-   * @summary Execute with cut (call_once) POST /api/v1/control/call-once
-   * @request POST:/api/v1/control/call-once
-   * @secure
-   */
-  controlCallOnce = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/call-once`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name ControlCond
-   * @summary Execute conditional (if-then-else) POST /api/v1/control/cond
-   * @request POST:/api/v1/control/cond
-   * @secure
-   */
-  controlCond = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/cond`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name ControlCut
-   * @summary Execute cut POST /api/v1/control/cut
-   * @request POST:/api/v1/control/cut
-   * @secure
-   */
-  controlCut = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/cut`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name ControlFindall
-   * @summary Collect all solutions (findall) POST /api/v1/control/findall
-   * @request POST:/api/v1/control/findall
-   * @secure
-   */
-  controlFindall = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/findall`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name ControlForall
-   * @summary Universal quantification (forall) POST /api/v1/control/forall
-   * @request POST:/api/v1/control/forall
-   * @secure
-   */
-  controlForall = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/forall`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name ControlImplies
-   * @summary Evaluate implication (A -> B) POST /api/v1/control/implies
-   * @request POST:/api/v1/control/implies
-   * @secure
-   */
-  controlImplies = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/implies`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name ControlNaf
-   * @summary Negation as failure POST /api/v1/control/naf
-   * @request POST:/api/v1/control/naf
-   * @secure
-   */
-  controlNaf = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/naf`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name ControlUndo
-   * @summary Register undo action POST /api/v1/control/undo
-   * @request POST:/api/v1/control/undo
-   * @secure
-   */
-  controlUndo = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/undo`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
   /**
    * No description
    *
@@ -8706,48 +9036,12 @@ var Control = class {
     format: "json",
     ...params
   });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name GlobalGet
-   * @summary Get global variable POST /api/v1/control/global/get
-   * @request POST:/api/v1/control/global/get
-   * @secure
-   */
-  globalGet = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/global/get`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
-  /**
-   * No description
-   *
-   * @tags control
-   * @name GlobalIncrement
-   * @summary Global increment POST /api/v1/control/global/incr
-   * @request POST:/api/v1/control/global/incr
-   * @secure
-   */
-  globalIncrement = (data, params = {}) => this.http.request({
-    path: `/api/v1/control/global/incr`,
-    method: "POST",
-    body: data,
-    secure: true,
-    type: "application/json",
-    format: "json",
-    ...params
-  });
   /**
    * No description
    *
    * @tags control
    * @name ImportModule
-   * @summary Import a module POST /api/v1/modules/import
+   * @summary Import one module into another POST /api/v1/modules/import
    * @request POST:/api/v1/modules/import
    * @secure
    */
@@ -8765,7 +9059,7 @@ var Control = class {
    *
    * @tags control
    * @name ListSymbols
-   * @summary List module symbols POST /api/v1/modules/:name/symbols/list
+   * @summary List a module's symbols, or every symbol visible from it POST /api/v1/modules/symbols/list
    * @request POST:/api/v1/modules/symbols/list
    * @secure
    */
@@ -8783,7 +9077,7 @@ var Control = class {
    *
    * @tags control
    * @name ResolveSymbol
-   * @summary Resolve qualified symbol name POST /api/v1/modules/resolve
+   * @summary Resolve a qualified symbol (`module#symbol`) POST /api/v1/modules/resolve
    * @request POST:/api/v1/modules/resolve
    * @secure
    */
@@ -9395,11 +9689,11 @@ var Analysis = class {
     ...params
   });
   /**
-   * @description The exploration must be complete (no more questions) before calling this. Registration happens before the terminal commit and ignores existing names, so a retry after a lost commit is safe. The committed receipt is retained: completing again returns it unchanged. `rules_created` counts those sort registrations; no inference rule is installed.
+   * @description The exploration must be complete (no more questions). Under the tenant's writer gate the route reads the authoritative action snapshot, rereads the session's source terms from it as the caller can see them, and reprojects them with the native presence projection: a source that was deleted, is hidden from the caller, or changed its feature names since the session started refuses publication, and nothing is published. Value-only edits do not, exactly as values do not enter the projection. Each accepted implication `A → B` is published, for every `c ∈ B`, as a native rule licensed for the session's frozen source population only (`expert-confirmed-frozen-population-v1`): for every original member holding `A`, forward and backward inference derive an obligation naming `c`, referencing that member and citing the licence record. No value of `c` is invented, no source term is modified, and no term outside the population, however similar, acquires an obligation. Rules, licence and population record commit in one checked action against that snapshot, so a concurrent source change refuses the commit. The committed receipt is retained: completing again returns it unchanged, and a publication that committed before a lost session commit is recognised and not repeated.
    *
    * @tags analysis
    * @name CompleteExploration
-   * @summary Complete the exploration and register appropriateness sorts for its basis.
+   * @summary Complete an exploration and publish its accepted implications as scoped native rules.
    * @request POST:/api/v1/analysis/attribute-exploration/{session_id}/complete
    */
   completeExploration = (sessionId, params = {}) => this.http.request({
@@ -9424,6 +9718,24 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags analysis
+   * @name DetectAnomalies
+   * @summary Flag the points of a series that leave its running baseline.
+   * @request POST:/api/v1/analysis/anomalies
+   * @secure
+   */
+  detectAnomalies = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/anomalies`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -9439,6 +9751,24 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Fits `target ~ 1 + features` by ordinary least squares on `rows`, then computes exact interventional Shapley values of the prediction at `instance`, enumerating every coalition over the rows as background (at most 12 features).
+   *
+   * @tags analysis
+   * @name ExplainWithShapley
+   * @summary Attribute a least-squares model's prediction to its features.
+   * @request POST:/api/v1/analysis/shapley
+   * @secure
+   */
+  explainWithShapley = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/shapley`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Names the pending question, so a client that lost a confirm/refute answer re-reads the question it must answer next and continues (#410).
    *
@@ -9468,6 +9798,24 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Fits simple, Holt (trend) or Holt-Winters (additive trend and season) exponential smoothing by minimising one-step-ahead squared error, backtests on the held-out end of the series, and forecasts `horizon` steps with approximate 95% intervals. Without `method`, every model the series is long enough for is backtested and the lowest-MAE one is used.
+   *
+   * @tags analysis
+   * @name ForecastSeries
+   * @summary Forecast a series by exponential smoothing.
+   * @request POST:/api/v1/analysis/forecast
+   * @secure
+   */
+  forecastSeries = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/forecast`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -9484,6 +9832,19 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags analysis
+   * @name InviteParticipant
+   * @summary Only the creator may explicitly invite a participant.
+   * @request PUT:/api/v1/analysis/attribute-exploration/{session_id}/participants/{participant_id}
+   */
+  inviteParticipant = (sessionId, participantId, params = {}) => this.http.request({
+    path: `/api/v1/analysis/attribute-exploration/${sessionId}/participants/${participantId}`,
+    method: "PUT",
+    ...params
+  });
   /**
    * @description A candidate reached by neither kind of hypothesis comes back `undetermined_no_hypothesis`, and one reached by both comes back `undetermined_contradictory` — different facts, reported apart, because the second says the examples disagree and the first says they are silent.
    *
@@ -9500,6 +9861,22 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description A separate, attributed declaration under `expert-declared-sort-v1`: the creator or an invited participant names a sort, and every confirmed implication of the session is installed as a native rule over every subject of that sort and its subsorts. Each obligation names the implied feature for its subject and cites a sort licence record, which names its declarer and extends the session's frozen-population licence; no value is invented and no source term changes. Licence and rules commit in one checked action. Repeating the request for the same sort returns the recorded licence without publishing again.
+   *
+   * @tags analysis
+   * @name LicenseExplorationSort
+   * @summary Extend a completed exploration's confirmed implications to every term of a sort.
+   * @request POST:/api/v1/analysis/attribute-exploration/{session_id}/licences
+   */
+  licenseExplorationSort = (sessionId, data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/attribute-exploration/${sessionId}/licences`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description This is the symbolic object of symbolic data analysis: the unit of interest is the group, its description is interval-valued where its members differ, and — once stored — it is an ordinary sort. A candidate whose deciding feature was never measured comes back `residuated`, naming what it is waiting for, rather than being reported outside the cohort.
    *
@@ -9595,6 +9972,19 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags analysis
+   * @name RevokeParticipant
+   * @summary Only the creator may explicitly revoke a participant.
+   * @request DELETE:/api/v1/analysis/attribute-exploration/{session_id}/participants/{participant_id}
+   */
+  revokeParticipant = (sessionId, participantId, params = {}) => this.http.request({
+    path: `/api/v1/analysis/attribute-exploration/${sessionId}/participants/${participantId}`,
+    method: "DELETE",
+    ...params
+  });
   /**
    * @description A returned concept with `generalized: true` and a `sort` naming none of its members' sorts is the case this endpoint exists for: a point in the lattice no attribute names, reached because the least upper bound of two sorts is a derivation in the hierarchy. Read `truncated` before reading `concepts` as "what the population contains". An empty `concepts` list is an abstention, not a rate of zero. ⚠️ `concepts[].lower_bound` is a **ranking key, not a certificate**: the search chose those concepts by looking at the very degrees the bound is computed on. Send a `holdout` to get claims — the search then sees only the selection half, and `certificates[]` carries bounds measured on data it never saw, corrected for the number of claims rather than the number searched.
    *
@@ -10666,7 +11056,7 @@ var Admin = class {
     ...params
   });
   /**
-   * @description Explicitly creates a tenant's registry row, inference state and sort hierarchy, optionally seeding initial sorts and storing a display label. Idempotent. No X-Tenant-Id header required. Refuses a deleted tenant's UUID with 409 rather than resurrecting it.
+   * @description Explicitly creates a tenant's registry row, inference state and sort hierarchy, optionally seeding initial sorts and storing a display label. Idempotent. A caller may provision its own tenant (body tenant_id equal to its X-Tenant-Id); any other id, or a generated one, requires the platform_admin role (403 otherwise). Refuses a deleted tenant's UUID with 409 rather than resurrecting it.
    *
    * @tags admin
    * @name CreateTenant
@@ -11617,6 +12007,24 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name CompleteDsr
+   * @summary Complete a data subject request
+   * @request POST:/api/v1/dsr/{id}/complete
+   * @secure
+   */
+  completeDsr = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/dsr/${id}/complete`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -11635,6 +12043,24 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name DenyDsr
+   * @summary Deny a data subject request
+   * @request POST:/api/v1/dsr/{id}/deny
+   * @secure
+   */
+  denyDsr = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/dsr/${id}/deny`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @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.
    *
@@ -11653,6 +12079,58 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Every matching record, oldest first: `jsonl` writes each record as stored (hashes included, so the chain can be re-verified downstream); `cef` writes one ArcSight CEF line per record. The `X-Audit-Chain-Verified` header says whether the tenant's whole chain verified at export time.
+   *
+   * @tags compliance
+   * @name Export
+   * @summary Export the compliance ledger as JSON Lines or CEF
+   * @request GET:/api/v1/compliance/audit/export
+   * @secure
+   */
+  export = (query, params = {}) => this.http.request({
+    path: `/api/v1/compliance/audit/export`,
+    method: "GET",
+    query,
+    secure: true,
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name ExportDsr
+   * @summary Answer an access or portability request with the subject's data
+   * @request POST:/api/v1/dsr/{id}/export
+   * @secure
+   */
+  exportDsr = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/dsr/${id}/export`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name ExtendDsr
+   * @summary Extend a data subject request's deadline
+   * @request POST:/api/v1/dsr/{id}/extend
+   * @secure
+   */
+  extendDsr = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/dsr/${id}/extend`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description One record of the tenant's ledger, by the id a mutating response names in its `x-osfkb-audit-record` header. A record of another tenant is `404`, exactly like an id that was never issued.
    *
@@ -11669,6 +12147,22 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name GetAuditRetention
+   * @summary Read the tenant's retention policy.
+   * @request GET:/api/v1/compliance/audit/retention
+   * @secure
+   */
+  getAuditRetention = (params = {}) => this.http.request({
+    path: `/api/v1/compliance/audit/retention`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -11759,13 +12253,32 @@ var Compliance = class {
    * @request GET:/api/v1/dsr
    * @secure
    */
-  listDsr = (params = {}) => this.http.request({
+  listDsr = (query, params = {}) => this.http.request({
     path: `/api/v1/dsr`,
     method: "GET",
+    query,
     secure: true,
     format: "json",
     ...params
   });
+  /**
+   * @description Removes the longest prefix of the tenant's ledger that is older than `before` and than the retention minimum, and that no kept record still needs (as a cause, an informer, or a scope it shares). The chain then verifies from an anchor, and the purge appends a `retention.purge` record that pins it. `dry_run` reports the cut and changes nothing.
+   *
+   * @tags compliance
+   * @name PurgeAuditLedger
+   * @summary Remove the oldest audit records the retention policy and the causal structure allow.
+   * @request POST:/api/v1/compliance/audit/purge
+   * @secure
+   */
+  purgeAuditLedger = (data, params = {}) => this.http.request({
+    path: `/api/v1/compliance/audit/purge`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Who delegated to whom: every scope with its parent, depth, opener, seal and commitment — the question the causal channel alone cannot answer.
    *
@@ -11782,6 +12295,24 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name SetAuditRetention
+   * @summary Set the tenant's retention policy.
+   * @request PUT:/api/v1/compliance/audit/retention
+   * @secure
+   */
+  setAuditRetention = (data, params = {}) => this.http.request({
+    path: `/api/v1/compliance/audit/retention`,
+    method: "PUT",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -11798,6 +12329,24 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name ValidateSnapshot
+   * @summary Validate a snapshot against the ground truth the caller supplies.
+   * @request POST:/api/v1/predictions/snapshot/{id}/validate
+   * @secure
+   */
+  validateSnapshot = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/predictions/snapshot/${id}/validate`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Runs validation with a built-in stub provider that returns `Pending` for every entry. Real consumers wire their own `GroundTruthProviderPort` implementation and call `PredictionLedgerPort::validate` from a service.
    *
@@ -11830,6 +12379,24 @@ var Compliance = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags compliance
+   * @name VerifyDsr
+   * @summary Verify a data subject's identity
+   * @request POST:/api/v1/dsr/{id}/verify
+   * @secure
+   */
+  verifyDsr = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/dsr/${id}/verify`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Snapshots.ts
@@ -12072,7 +12639,7 @@ var Subscriptions = class {
     this.http = http;
   }
   /**
-   * @description `POST /api/v1/subscriptions`. The subscription survives a restart. Each matched event is POSTed to `url` off the request path: BEST-EFFORT with bounded retry. There is no outbox — an event whose retries are exhausted, or one produced while the process dies, is LOST, and a retry after an ambiguous failure may DUPLICATE. The SUBSCRIPTION is durable; the EVENT is not. `GET /api/v1/subscriptions` reports the delivery counters. Sort matching is by SUBSUMPTION: a subscription on `person` receives an `employee` event. Set `exact` to demand name equality.
+   * @description `POST /api/v1/subscriptions`. The subscription survives a restart. Each matched event is written to the subscription's outbox and POSTed to `url` off the request path, retried up to `max_retries` times with a backoff that starts at `backoff_ms` and doubles. A refused or exhausted event is kept as a dead letter (`GET /api/v1/subscriptions/{id}/deliveries`, then `POST …/deliveries/{delivery_id}/redrive`); with a database the outbox survives a restart. Delivery is at least once: a retry after an ambiguous failure may DUPLICATE. `GET /api/v1/subscriptions` reports the counters. Sort matching is by SUBSUMPTION: a subscription on `person` receives an `employee` event. Set `exact` to demand name equality.
    *
    * @tags subscriptions
    * @name CreateSubscription
@@ -12104,6 +12671,23 @@ var Subscriptions = class {
     secure: true,
     ...params
   });
+  /**
+   * @description The subscription's outbox, newest first: every matched event is an entry before any POST. `pending` entries wait for their next attempt (exponential backoff from `backoff_ms`); a 2xx answer makes an entry `delivered`; a 3xx or 4xx (except 408 and 429), or running out of attempts, makes it `dead` until it is redriven. The newest 100 delivered entries are kept. Durable when the engine has a database.
+   *
+   * @tags subscriptions
+   * @name ListSubscriptionDeliveries
+   * @summary List a subscription's deliveries.
+   * @request GET:/api/v1/subscriptions/{id}/deliveries
+   * @secure
+   */
+  listSubscriptionDeliveries = (id, query, params = {}) => this.http.request({
+    path: `/api/v1/subscriptions/${id}/deliveries`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description `GET /api/v1/subscriptions`. Each entry carries its retry policy as stored and its delivery counters, so "what happened to my deliveries" needs no further route.
    *
@@ -12120,6 +12704,22 @@ var Subscriptions = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Makes a `dead` delivery `pending` again with its attempts reset, due at once; it is attempted with the subscription's current retry budget. Its last error is kept until the next attempt.
+   *
+   * @tags subscriptions
+   * @name RedriveSubscriptionDelivery
+   * @summary Put a dead letter back in line.
+   * @request POST:/api/v1/subscriptions/{id}/deliveries/{delivery_id}/redrive
+   * @secure
+   */
+  redriveSubscriptionDelivery = (id, deliveryId, params = {}) => this.http.request({
+    path: `/api/v1/subscriptions/${id}/deliveries/${deliveryId}/redrive`,
+    method: "POST",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description `PATCH /api/v1/subscriptions/{id}`. An omitted field keeps its stored value; `"sort": null` removes the sort filter. `enabled: false` pauses delivery — no later event reaches the target — and `enabled: true` resumes it. The id, the creation time and the delivery counters are kept, so pausing or retargeting a subscription loses none of its delivery history. The edited config is validated as create validates it, including the SSRF check on the URL — the stored URL too, when the edit leaves it unchanged. A subscription belonging to another tenant answers 404, never 403.
    *
@@ -13320,6 +13920,23 @@ var Documents = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Renders Markdown (headings, paragraphs, bullet lists) as a Word document (WordprocessingML) or an A4 PDF in Helvetica. PDF text is WinAnsi-encoded: Latin-1 renders, other characters become `?`.
+   *
+   * @tags documents
+   * @name ExportDocument
+   * @summary Render a Markdown document as DOCX or PDF.
+   * @request POST:/api/v1/documents/export
+   * @secure
+   */
+  exportDocument = (data, params = {}) => this.http.request({
+    path: `/api/v1/documents/export`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    ...params
+  });
   /**
    * No description
    *
@@ -13935,6 +14552,22 @@ var Sat = class {
   constructor(http) {
     this.http = http;
   }
+  /**
+   * No description
+   *
+   * @tags sat
+   * @name SolveMaxsat
+   * @summary Solve a weighted partial MaxSAT instance.
+   * @request POST:/api/v1/sat/maxsat
+   */
+  solveMaxsat = (data, params = {}) => this.http.request({
+    path: `/api/v1/sat/maxsat`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Runs the in-process CDCL engine (two-watched-literal propagation, 1-UIP conflict analysis, VSIDS, Luby restarts, GF(2) parity presolve). This is distinct from the external OR-Tools microservice at `/api/v1/solver/solve`. No tenant context is required. The solver is stateless; each request spins up an independent solver instance.
    *
@@ -15328,6 +15961,24 @@ var Channels = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Registers an adapter the tenant sends through (`POST /channels/messages` with `adapter_name`): a `webhook` (one JSON POST to `url` per delivery; with a `secret` it carries `X-OSFKB-Timestamp` and `X-OSFKB-Signature: v1=<hex HMAC-SHA256(secret, timestamp + "." + body)>`), a `slack`, `telegram` or `discord` bot with the tenant's own `token`, or an `email` mailbox (`smtp_host`, `smtp_port`, `smtp_username`, `smtp_password`, `from`; the channel id is the recipient address). A platform's API base comes from the deployment, never from the request. Private and loopback targets (a webhook URL at delivery, an SMTP host at registration) are refused unless OSFKB_SUBSCRIPTION_ALLOW_PRIVATE_TARGETS allows them. With a database a registration is stored and every engine serves it, and its secret (signing key, token, SMTP password) is sealed in the credential vault under OSFKB_CREDENTIAL_VAULT_KEY (a secret without the key is refused with 503); without a database registrations are held in this process.
+   *
+   * @tags channels
+   * @name RegisterChannelAdapter
+   * @summary Register a channel adapter for the tenant.
+   * @request POST:/api/v1/channels/adapters
+   * @secure
+   */
+  registerChannelAdapter = (data, params = {}) => this.http.request({
+    path: `/api/v1/channels/adapters`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Maps `(platform, account_id, thread_id)` to an agent of the caller's tenant, so inbound messages on that account reach it. The route is filed under the authenticated tenant; the body `tenant_id` is not used. A route another tenant already owns is refused.
    *
@@ -15347,7 +15998,7 @@ var Channels = class {
     ...params
   });
   /**
-   * @description POST /api/v1/channels/messages NOTE: `ChannelService::send_message` holds a `parking_lot::RwLockReadGuard` across `.await` (the guard is not `Send`), which prevents direct use in an Axum handler. We work around this by spawning the call on a blocking task via `tokio::task::spawn_blocking` wrapped in an async block.
+   * @description POST /api/v1/channels/messages
    *
    * @tags channels
    * @name SendChannelMessage
@@ -15365,7 +16016,7 @@ var Channels = class {
     ...params
   });
   /**
-   * @description POST /api/v1/channels/typing Same `block_in_place` bridge as `send_message` — see its doc comment.
+   * @description POST /api/v1/channels/typing
    *
    * @tags channels
    * @name SendChannelTyping
@@ -15382,6 +16033,21 @@ var Channels = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags channels
+   * @name UnregisterChannelAdapter
+   * @summary Remove an adapter the tenant registered.
+   * @request DELETE:/api/v1/channels/adapters/{name}
+   * @secure
+   */
+  unregisterChannelAdapter = (name, params = {}) => this.http.request({
+    path: `/api/v1/channels/adapters/${name}`,
+    method: "DELETE",
+    secure: true,
+    ...params
+  });
 };
 
 // src/api-spec/generated/Platform.ts
@@ -15554,6 +16220,42 @@ var Platform = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Creates or replaces the caller's identity for `agent_id`. `assistant` is the tenant's conversation persona; a cognitive agent's id names that agent's identity on channels.
+   *
+   * @tags platform
+   * @name PutAgentIdentity
+   * @summary Write an agent identity
+   * @request PUT:/api/v1/identities/{agent_id}
+   * @secure
+   */
+  putAgentIdentity = (agentId, data, params = {}) => this.http.request({
+    path: `/api/v1/identities/${agentId}`,
+    method: "PUT",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * @description POST /api/v1/skills
+   *
+   * @tags platform
+   * @name RegisterSkill
+   * @summary Register a skill
+   * @request POST:/api/v1/skills
+   * @secure
+   */
+  registerSkill = (data, params = {}) => this.http.request({
+    path: `/api/v1/skills`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Runs every registered check of the engine process (system, database, cache and similar) and reports each result. The checks describe the process, not a tenant.
    *
@@ -17455,7 +18157,7 @@ var RESPONSE_COMPONENTS = {
     }
   },
   ActiveReleaseDto: { object: { active_revision: [1, 0] } },
-  AdapterInfoDto: { object: { name: [1, 0], platform: [1, 0], status: [1, 0] } },
+  AdapterInfoDto: { object: { name: [1, 0], owned: [1, 0], platform: [1, 0], status: [1, 0] } },
   AdaptiveModifyResponse: { object: { message: [1, 0], success: [1, 0] } },
   AddBeliefResponse: { object: { belief_id: [1, 0], message: [1, 0] } },
   AddCausalRelationResponse: { object: { message: [1, 0], rule_id: [1, 0], success: [1, 0] } },
@@ -17497,6 +18199,15 @@ var RESPONSE_COMPONENTS = {
       term_id: [1, 0]
     }
   },
+  AgentBundle: {
+    object: {
+      beliefs: [0, { array: "BundleBelief" }],
+      config: [0, "AgentConfigDto"],
+      format: [1, 0],
+      goals: [0, { array: "BundleGoal" }]
+    }
+  },
+  AgentConfigDto: { object: {} },
   AgentContext: {
     object: {
       domain_expertise: [1, { array: 0 }],
@@ -17564,6 +18275,21 @@ var RESPONSE_COMPONENTS = {
   AgentRecallAsOfResponse: {
     object: { as_of_ts: [1, 0], count: [1, 0], episode_ids: [1, { array: 0 }] }
   },
+  AgentRun: {
+    object: {
+      actions_executed: [1, 0],
+      agent_id: [1, 0],
+      duration_ms: [1, 0],
+      finished_at: [1, 0],
+      goals_achieved: [1, 0],
+      goals_failed: [1, 0],
+      kind: [1, 0],
+      run_id: [1, 0],
+      started_at: [1, 0],
+      status: [1, 0]
+    }
+  },
+  AgentRunsResponse: { object: { agent_id: [1, 0], runs: [1, { array: "AgentRun" }] } },
   AgentStateDto: {
     object: {
       agent_id: [1, 0],
@@ -17621,6 +18347,15 @@ var RESPONSE_COMPONENTS = {
     }
   },
   AmbiguousLabelDto: { object: { concepts: [1, { array: 0 }], label: [1, 0] } },
+  AnomalyDto: { object: { index: [1, 0], score: [1, 0], value: [1, 0] } },
+  AnomalyResponse: {
+    object: {
+      anomalies: [1, { array: "AnomalyDto" }],
+      method: [1, 0],
+      scored: [1, 0],
+      threshold: [1, 0]
+    }
+  },
   AnonymizeResponse: {
     object: {
       k_anonymity_result: [2, { object: {} }],
@@ -17865,6 +18600,15 @@ var RESPONSE_COMPONENTS = {
       warnings: [0, { array: 0 }]
     }
   },
+  AuditAnchor: {
+    object: {
+      base_hash: [1, 0],
+      purge_record_id: [1, 0],
+      purged_count: [1, 0],
+      purged_through: [1, 0],
+      purged_through_at: [1, 0]
+    }
+  },
   AuditEntryDto: {
     object: {
       action: [1, 0],
@@ -17946,12 +18690,13 @@ var RESPONSE_COMPONENTS = {
   BacktrackTermStoreResponse: {
     object: { current_trail_length: [1, 0], success: [1, 0], undone_entries: [1, 0] }
   },
-  BacktrackableAssignResponse: {
-    object: { feature_name: [1, 0], term_id: [1, 0], trail_entry_added: [1, 0] }
-  },
   BackupResponse: { object: { created_at: [1, 0], id: [1, 0], name: [1, 0], status: [1, 0] } },
   BackwardChainResponse: {
-    object: { query_time_ms: [1, 0], solutions: [1, { array: "SolutionDto" }] }
+    object: {
+      query_time_ms: [1, 0],
+      solutions: [1, { array: "SolutionDto" }],
+      why_not: [2, "WhyNotDto"]
+    }
   },
   BaselineDto: { object: { snapshot_hash: [1, 0], stale: [1, 0] } },
   BatchCopyResponse: { object: { copies: [1, { array: "CopyResultDto" }] } },
@@ -18149,6 +18894,10 @@ var RESPONSE_COMPONENTS = {
   BulkRowRefusalDto: { object: { index: [1, 0], message: [1, 0] } },
   BulkSetSimilaritiesResponse: { object: { errors: [0, { array: 0 }], set_count: [1, 0] } },
   BulkSortError: { object: { error: [1, 0], kind: [1, 0], name: [1, 0], sort_created: [1, 0] } },
+  BundleBelief: {
+    object: { confidence: [1, 0], features: [0, { object: {} }], sort: [1, 0], source: [1, 0] }
+  },
+  BundleGoal: { object: { features: [0, { object: {} }], sort: [1, 0] } },
   CalibrationReportDto: {
     object: {
       augmentation_targets: [1, { array: "AugmentationTargetDto" }],
@@ -18158,7 +18907,6 @@ var RESPONSE_COMPONENTS = {
       total_predictions: [1, 0]
     }
   },
-  CallOnceResponse: { object: { choice_points_cut: [1, 0], success: [1, 0] } },
   CancelDocumentResponse: { object: { cancelled: [1, 0], message: [1, 0] } },
   CandidateCellDto: { object: { members: [1, 0], value: [1, 0] } },
   CandidateDetailResponse: {
@@ -18235,6 +18983,72 @@ var RESPONSE_COMPONENTS = {
     }
   },
   CatalogPageDto: { object: { items: [1, { array: "PluginSummaryDto" }], total: [1, 0] } },
+  CateAtDto: { object: { features: [1, { array: 0 }], tau: [1, 0] } },
+  CateResponse: {
+    object: { coverage: [1, 0], effects: [1, { array: "CateAtDto" }], method: [1, 0] }
+  },
+  CategoricalAnswer: {
+    object: { finding: [1, 0], observation: [1, 0], pattern: [1, 0], present: [1, 0] }
+  },
+  CategoricalComponent: {
+    object: {
+      context_log_weight: [1, 0],
+      contributions: [1, { array: "FactorContribution" }],
+      group: [1, 0],
+      head: [1, 0],
+      name: [1, 0],
+      non_probabilistic_annotations: [1, { array: 0 }],
+      prior: [1, 0],
+      prior_scale: [1, 0],
+      probability: [1, 0],
+      rule: [1, 0]
+    }
+  },
+  CategoricalPolicy: {
+    object: {
+      asked: [0, { array: 0 }],
+      observation_metadata: [0, { array: 0 }],
+      time_window: [2, { array: 0 }]
+    }
+  },
+  CategoricalQuestion: {
+    object: { finding: [1, 0], information_bits: [1, 0], pattern: [1, 0], probability_yes: [1, 0] }
+  },
+  CategoricalRanking: {
+    object: {
+      alerts: [1, { array: 0 }],
+      components: [1, { array: 0 }],
+      name: [1, 0],
+      probability: [1, 0],
+      support_count: [1, 0]
+    }
+  },
+  CategoricalResult: {
+    object: {
+      answers: [1, { array: "CategoricalAnswer" }],
+      comparisons: [1, 0],
+      completed: [1, 0],
+      components: [1, { array: "CategoricalComponent" }],
+      context_effects: [1, { array: "ContextEffect" }],
+      decision_status: [1, 0],
+      evaluation: [1, { object: {} }],
+      excluded_observations: [1, { array: 0 }],
+      goal: [1, 0],
+      input_etags: [1, { object: {} }],
+      leader_support: [1, 0],
+      margin: [1, 0],
+      policy: [1, "CategoricalPolicy"],
+      present_count: [1, 0],
+      questions: [1, { array: "CategoricalQuestion" }],
+      ranking: [1, { array: "CategoricalRanking" }],
+      redundant_observations: [1, { array: 0 }],
+      retained_observations: [1, { array: 0 }],
+      schema_digest: [1, 0],
+      scope: [1, { object: {} }],
+      semantics: [1, 0]
+    }
+  },
+  CategoricalVerifyResponse: { object: { replay_matches: [1, 0], semantics: [1, 0] } },
   CategoryProbabilityDto: { object: { probability: [1, 0], value: [1, 0] } },
   CausalAncestorResponse: {
     object: { explanation: [1, 0], is_ancestor: [1, 0], path: [1, { array: 0 }] }
@@ -18305,6 +19119,13 @@ var RESPONSE_COMPONENTS = {
       sort: [1, 0]
     }
   },
+  CensoringDiagnosticDto: {
+    object: {
+      censoring_survival_at_horizon: [1, 0],
+      fraction_censored_before_horizon: [1, 0],
+      max_weight: [1, 0]
+    }
+  },
   CentralityResponse: {
     object: {
       edge_count: [1, 0],
@@ -18345,6 +19166,8 @@ var RESPONSE_COMPONENTS = {
       circular: [1, 0],
       claims: [1, { array: "CertifiedClaimDto" }],
       concepts: [1, 0],
+      concepts_complete: [1, 0],
+      population_sampled: [1, 0],
       target_feature: [1, 0]
     }
   },
@@ -18763,6 +19586,7 @@ var RESPONSE_COMPONENTS = {
       assignments: [1, { array: "TermAssignmentDto" }],
       base_rate: [1, 0],
       below_support: [1, 0],
+      coverage: [1, "MiningCoverageDto"],
       depth: [1, 0],
       evidence_status: [1, 0],
       examined: [1, 0],
@@ -18816,6 +19640,7 @@ var RESPONSE_COMPONENTS = {
     object: {
       base_rate: [1, 0],
       candidates: [1, { array: "ConceptRuleCandidateDto" }],
+      coverage: [2, "MiningCoverageDto"],
       examined: [1, 0],
       input_complete: [1, 0],
       input_stop_reason: [1, 0],
@@ -18860,9 +19685,6 @@ var RESPONSE_COMPONENTS = {
       memberships: [1, { array: "MembershipViewDto" }]
     }
   },
-  CondResponse: {
-    object: { branch_executed: [1, 0], condition_succeeded: [1, 0], success: [1, 0] }
-  },
   ConditionalIndependenceResponse: { object: { explanation: [1, 0], independent: [1, 0] } },
   ConfigFieldDto: { object: { name: [1, 0], required: [1, 0], type: [1, 0] } },
   ConfigSectionResponse: { object: { description: [1, 0], entry_count: [1, 0], name: [1, 0] } },
@@ -19028,6 +19850,17 @@ var RESPONSE_COMPONENTS = {
   },
   ContentHashResponse: { object: { algorithm: [1, 0], hash: [1, 0] } },
   ContextComponentDto: { object: { id: [1, 0], kind: [1, 0], version: [1, 0] } },
+  ContextEffect: {
+    object: {
+      applied: [1, 0],
+      log_weight: [1, 0],
+      rule: [1, 0],
+      rule_certainty: [1, 0],
+      status: [1, 0],
+      target: [1, 0],
+      witnesses: [1, { array: "ContextWitness" }]
+    }
+  },
   ContextManifestDto: {
     object: {
       components: [1, { array: "ContextComponentDto" }],
@@ -19048,6 +19881,7 @@ var RESPONSE_COMPONENTS = {
       state: [1, 0]
     }
   },
+  ContextWitness: { object: { degree: [1, 0], premises: [1, { array: "ContextWitness" }] } },
   Contradiction: {
     object: {
       claim_a_id: [1, 0],
@@ -19078,7 +19912,8 @@ var RESPONSE_COMPONENTS = {
       dropped: [1, 0],
       facets: [1, { array: "FacetContrastDto" }],
       population_a: [1, 0],
-      population_b: [1, 0]
+      population_b: [1, 0],
+      population_sampled: [1, 0]
     }
   },
   ConversationAnswerFeedbackResponseDto: {
@@ -19257,7 +20092,7 @@ var RESPONSE_COMPONENTS = {
       should_curry: [1, 0]
     }
   },
-  CutResponse: { object: { choice_points_removed: [1, 0] } },
+  CutStop: { object: { reason: [1, 0], record_id: [1, 0] } },
   CycleDto: {
     object: { edges: [1, { array: 0 }], is_problematic: [1, 0], nodes: [1, { array: 0 }] }
   },
@@ -19542,6 +20377,17 @@ var RESPONSE_COMPONENTS = {
   DirectionConstraintCheck: {
     object: { allowed: [1, 0], cause: [1, 0], effect: [1, 0], explanation: [1, 0] }
   },
+  DiscontinuityResponse: {
+    object: {
+      bandwidth: [1, 0],
+      ci_lower: [1, 0],
+      ci_upper: [1, 0],
+      effect: [1, 0],
+      n_left: [1, 0],
+      n_right: [1, 0],
+      std_error: [1, 0]
+    }
+  },
   DiscoverCausalResponse: {
     object: {
       data_needed: [2, { array: "DataNeededDto" }],
@@ -19646,6 +20492,15 @@ var RESPONSE_COMPONENTS = {
       suggested_parents: [0, { array: 0 }]
     }
   },
+  DiscoveryInterpretationDto: {
+    object: {
+      complete: [1, 0],
+      kind: [1, 0],
+      scaled_attribute_count: [1, 0],
+      truncated: [1, 0],
+      unscaled_value_count: [1, 0]
+    }
+  },
   DiscoveryProofNodeDto: {
     object: { depth: [1, 0], explanation: [1, 0], id: [1, 0], step_type: [1, 0] }
   },
@@ -19666,6 +20521,22 @@ var RESPONSE_COMPONENTS = {
       undirected_edge_count: [1, 0]
     }
   },
+  DisentailmentBatchResponse: {
+    object: {
+      completed: [1, 0],
+      computation_time_ms: [1, 0],
+      results: [1, { array: "DisentailmentBatchResult" }]
+    }
+  },
+  DisentailmentBatchResult: {
+    object: {
+      antecedent_degree: [1, 0],
+      consequent_degree: [1, 0],
+      id: [1, 0],
+      violated: [1, 0],
+      violation_degree: [1, 0]
+    }
+  },
   DisentailmentResponse: {
     object: {
       antecedent_degree: [1, 0],
@@ -19859,9 +20730,26 @@ var RESPONSE_COMPONENTS = {
       status: [1, 0]
     }
   },
+  DocumentUpload: {
+    object: {
+      chunk_bytes: [1, 0],
+      chunk_sha256: [1, { array: 0 }],
+      created_at: [1, 0],
+      id: [1, 0],
+      name: [1, 0],
+      owner_id: [1, 0],
+      size: [1, 0],
+      status: [1, 0],
+      updated_at: [1, 0],
+      uploaded_bytes: [1, 0]
+    }
+  },
+  DocumentUploadChunkReceipt: { object: { sha256: [1, 0], uploaded_bytes: [1, 0] } },
+  DocumentUploadsResponse: { object: { uploads: [1, { array: "DocumentUpload" }] } },
   DocumentVersionsResponse: {
     object: { family_id: [1, 0], versions: [1, { array: "DocumentDto" }] }
   },
+  DonorWeightDto: { object: { name: [1, 0], weight: [1, 0] } },
   DoseResponseResponse: {
     object: {
       ci_lower: [1, 0],
@@ -19891,6 +20779,14 @@ var RESPONSE_COMPONENTS = {
   DriveDto: {
     object: { activation: [1, 0], baseline: [1, 0], decay_rate: [1, 0], drive_type: [1, 0] }
   },
+  DsrExportResponse: {
+    object: {
+      content: [1, 0],
+      format: [1, 0],
+      record_count: [1, 0],
+      request: [1, "DsrRecordResponse"]
+    }
+  },
   DsrRecordResponse: {
     object: {
       data_subject: [1, 0],
@@ -19996,6 +20892,7 @@ var RESPONSE_COMPONENTS = {
       specificity: [2, "SpecificityDto"]
     }
   },
+  EmergencyStopStatus: { object: { engaged: [1, 0] } },
   EncodeClipResponse: {
     object: {
       clip_id: [1, 0],
@@ -20089,6 +20986,16 @@ var RESPONSE_COMPONENTS = {
       total_episodes: [1, 0]
     }
   },
+  EpistemicEntriesResponse: { object: { entries: [1, { array: "EpistemicEntryDto" }] } },
+  EpistemicEntryDto: {
+    object: {
+      evidence_notes: [1, { array: 0 }],
+      evidence_terms: [1, { array: 0 }],
+      id: [1, 0],
+      status: [1, 0],
+      subject: [1, 0]
+    }
+  },
   EpochMetricsDto: {
     object: { data_satisfaction: [1, 0], knowledge_satisfaction: [1, 0], total_loss: [1, 0] }
   },
@@ -20193,6 +21100,7 @@ var RESPONSE_COMPONENTS = {
     object: {
       counterexamples_added: [1, 0],
       implications: [1, { array: "ImplicationDto" }],
+      publication: [2, "ExplorationPublicationDto"],
       rules_created: [1, 0],
       total_implications: [1, 0]
     }
@@ -20205,6 +21113,16 @@ var RESPONSE_COMPONENTS = {
       is_complete: [1, 0]
     }
   },
+  ExplorationPublicationDto: {
+    object: {
+      installed_rules: [1, { array: 0 }],
+      licence_record: [1, 0],
+      policy: [1, 0],
+      population_record: [1, 0],
+      scope_members: [1, 0],
+      subject_sort_ids: [1, { array: 0 }]
+    }
+  },
   ExplorationQuestionDto: {
     object: {
       conclusion: [1, { array: 0 }],
@@ -20344,6 +21262,17 @@ var RESPONSE_COMPONENTS = {
     }
   },
   FactorChildrenDto: { object: { children: [1, { array: "ChildCandidateDto" }], factor: [1, 0] } },
+  FactorContribution: {
+    object: {
+      background: [1, 0],
+      finding: [1, 0],
+      frequency: [1, 0],
+      likelihood: [1, 0],
+      membership: [1, 0],
+      observation: [1, 0],
+      present: [1, 0]
+    }
+  },
   FactorMemberSortDto: { object: { id: [1, 0], name: [1, 0] } },
   FactorProposalDto: {
     object: {
@@ -20368,6 +21297,25 @@ var RESPONSE_COMPONENTS = {
     }
   },
   FailedReviewDto: { object: { reason: [1, 0], review_id: [1, 0] } },
+  FcaIngestionRecommendationDto: {
+    object: {
+      confidence: [1, 0],
+      features: [1, { array: 0 }],
+      sort_name: [1, 0],
+      term_count: [1, 0]
+    }
+  },
+  FcaIngestionReportDto: {
+    object: {
+      analysed_terms: [1, 0],
+      concepts_enumerated: [1, 0],
+      concepts_matching_existing: [1, 0],
+      input_complete: [1, 0],
+      recommendations: [1, { array: "FcaIngestionRecommendationDto" }],
+      search_complete: [1, 0],
+      stop_reason: [1, 0]
+    }
+  },
   FcaSearchSummaryDto: {
     object: {
       complete: [1, 0],
@@ -20391,7 +21339,6 @@ var RESPONSE_COMPONENTS = {
   FeatureRequirementDto: { object: { name: [1, 0] } },
   FindPlansResponse: { object: { count: [1, 0], plans: [1, { array: "PlanMatchDto" }] } },
   FindRulesResponse: { object: { matching_rules: [1, { array: "RuleDto" }] } },
-  FindallResponse: { object: { count: [1, 0], solutions: [1, { array: 0 }] } },
   FindingContextDto: {
     object: { related_record_ids: [1, { array: 0 }], roles: [1, { array: 0 }] }
   },
@@ -20405,7 +21352,6 @@ var RESPONSE_COMPONENTS = {
   FocusEntryDto: {
     object: { activation: [1, 0], rank: [1, 0], sort_name: [1, 0], term_id: [1, 0] }
   },
-  ForallResponse: { object: { result: [1, 0], solutions_tested: [1, 0] } },
   ForecastDomainDto: {
     object: {
       event_sort: [1, 0],
@@ -20543,6 +21489,7 @@ var RESPONSE_COMPONENTS = {
   FuzzyProveResponse: {
     object: {
       certificate: [0, { object: {} }],
+      next_questions: [0, { array: "NextQuestionDto" }],
       query_time_ms: [1, 0],
       solutions: [1, { array: "SolutionDto" }]
     }
@@ -20608,7 +21555,8 @@ var RESPONSE_COMPONENTS = {
       candidates: [1, { array: "CandidateFacetDto" }],
       materialized: [2, "FacetDto"],
       parent: [1, 0],
-      population: [1, 0]
+      population: [1, 0],
+      population_sampled: [1, 0]
     }
   },
   GenerateNegativesResponse: {
@@ -20767,8 +21715,6 @@ var RESPONSE_COMPONENTS = {
       step: [1, 0]
     }
   },
-  GlobalAssignResponse: { object: { variable_name: [1, 0] } },
-  GlobalIncrementResponse: { object: { new_value: [1, 0], variable_name: [1, 0] } },
   GoalEvaluationResultDto: {
     object: {
       confidence: [1, 0],
@@ -21030,7 +21976,9 @@ var RESPONSE_COMPONENTS = {
   ImageSuggestedSortDto: { object: { features: [1, { array: 0 }], name: [1, 0] } },
   ImpasseDto: { object: { description: [1, 0], goal_id: [1, 0], type: [1, 0] } },
   ImplicationDto: { object: { conclusion: [1, { array: 0 }], premise: [1, { array: 0 }] } },
-  ImpliesResponse: { object: { antecedent_succeeded: [1, 0], result: [1, 0] } },
+  ImportAgentResponse: {
+    object: { agent_id: [1, 0], beliefs_imported: [1, 0], goals_imported: [1, 0], name: [1, 0] }
+  },
   ImportAxiomsResponseDto: {
     object: {
       axioms: [1, 0],
@@ -21098,6 +22046,16 @@ var RESPONSE_COMPONENTS = {
   IncomingWebhookResponse: { object: { processed: [1, 0] } },
   IncompleteDocumentDto: { object: { document_id: [1, 0], resume_from_chunk: [1, 0] } },
   IndexSortsResponse: { object: { elapsed_ms: [1, 0], indexed_count: [1, 0] } },
+  InferenceJobDto: {
+    object: {
+      id: [1, 0],
+      kind: [1, 0],
+      result: [2, { object: {} }],
+      status: [1, 0],
+      submitted_at: [1, 0]
+    }
+  },
+  InferenceJobsResponse: { object: { jobs: [1, { array: "InferenceJobDto" }] } },
   InfluenceDto: {
     object: {
       activating: [1, 0],
@@ -21252,6 +22210,7 @@ var RESPONSE_COMPONENTS = {
       entities_refused: [0, { array: "RefusedEntityDto" }],
       entity_merge_audit: [0, { array: "EntityMergeAuditDto" }],
       failed_chunks: [0, { array: "ChunkFailureDto" }],
+      fca_discovery: [2, "FcaIngestionReportDto"],
       grounding_stats: [0, "GroundingStatsDto"],
       ontology_verifier: [0, "OntologyVerifierStatsDto"],
       pipeline_quality: [0, "PipelineQualityStatsDto"],
@@ -21381,6 +22340,7 @@ var RESPONSE_COMPONENTS = {
       exhausted: [1, 0],
       objects: [1, 0],
       patterns: [1, { array: "RegionPatternDto" }],
+      population_sampled: [1, 0],
       skipped: [1, 0],
       specificity_bound: [1, 0],
       steps: [1, 0]
@@ -21474,6 +22434,19 @@ var RESPONSE_COMPONENTS = {
       scheme_id: [1, 0]
     }
   },
+  LateResponse: {
+    object: {
+      assumptions: [1, { array: "CausalAssumptionDto" }],
+      ci_lower: [1, 0],
+      ci_upper: [1, 0],
+      first_stage: [1, 0],
+      first_stage_f: [1, 0],
+      late: [1, 0],
+      n: [1, 0],
+      std_error: [1, 0],
+      weak_instrument: [1, 0]
+    }
+  },
   LatticeRuleCellDto: { object: { mass: [1, 0], probability: [1, 0], sort: [1, 0] } },
   LatticeRuleDto: {
     object: {
@@ -21496,6 +22469,7 @@ var RESPONSE_COMPONENTS = {
       exhausted: [1, 0],
       holdout: [2, "HoldoutSummaryDto"],
       meets: [1, 0],
+      population_sampled: [1, 0],
       scored: [1, 0],
       target_feature: [1, 0],
       transpositions: [1, 0],
@@ -21576,6 +22550,7 @@ var RESPONSE_COMPONENTS = {
       infeasible_by_entropy: [1, 0],
       initial_gap: [1, 0],
       population: [1, 0],
+      population_sampled: [1, 0],
       pruned_by_entropy: [1, 0],
       rules: [1, { array: "LatticeRuleDto" }],
       steps: [1, { array: "TraceStepDto" }],
@@ -21583,6 +22558,15 @@ var RESPONSE_COMPONENTS = {
       unweighted: [1, 0]
     }
   },
+  LearnRulesResponse: {
+    object: {
+      clauses: [1, { array: "LearnedClauseDto" }],
+      negatives: [1, 0],
+      positives: [1, 0],
+      uncovered: [1, { array: { array: 0 } }],
+      uncovered_positives: [1, 0]
+    }
+  },
   LearnSortSimilaritiesResponse: {
     object: {
       effect_feature: [1, 0],
@@ -21592,7 +22576,17 @@ var RESPONSE_COMPONENTS = {
       min_similarity: [1, 0]
     }
   },
+  LearnedClauseDto: {
+    object: {
+      body: [1, { array: "LearnedLiteralDto" }],
+      negatives_covered: [1, 0],
+      osfql: [1, 0],
+      positives_covered: [1, 0],
+      text: [1, 0]
+    }
+  },
   LearnedHypothesisDto: { object: { sort: [1, 0], support: [1, 0], term_id: [1, 0] } },
+  LearnedLiteralDto: { object: { args: [1, { array: 0 }], sort: [1, 0] } },
   LearnedPatternDto: {
     object: {
       base_case_inputs: [1, { array: 0 }],
@@ -21641,11 +22635,23 @@ var RESPONSE_COMPONENTS = {
       absent_from_store: [1, 0],
       base_rate: [1, 0],
       classes: [1, { array: "StructuralClassDto" }],
+      coverage: [1, "LggCoverageDto"],
       examined: [1, 0],
       generalizations: [1, 0],
+      population_sampled: [1, 0],
       target_feature: [1, 0]
     }
   },
+  LggCoverageDto: {
+    object: {
+      classes_dropped: [1, 0],
+      depth_limited: [1, 0],
+      examined_limited: [1, 0],
+      exhaustive: [1, 0],
+      frontier_dropped: [1, 0],
+      seeds_unused: [1, 0]
+    }
+  },
   LineageEdgeDto: {
     object: {
       child: [1, 0],
@@ -21782,6 +22788,12 @@ var RESPONSE_COMPONENTS = {
       speakers: [1, { array: "SpeakerProfileDto" }]
     }
   },
+  ListSubscriptionDeliveriesResponse: {
+    object: {
+      counts: [1, "SubscriptionDeliveryCountsDto"],
+      deliveries: [1, { array: "SubscriptionDeliveryDto" }]
+    }
+  },
   ListSubscriptionsResponse: { object: { subscriptions: [1, { array: "SubscriptionDto" }] } },
   ListSymbolsResponse: { object: { module_name: [1, 0], symbols: [1, { array: "SymbolDto" }] } },
   ListTablesResponse: {
@@ -21935,6 +22947,9 @@ var RESPONSE_COMPONENTS = {
       upserted: [1, { array: 0 }]
     }
   },
+  MaxSatResponse: {
+    object: { cost: [1, 0], iterations: [1, 0], model: [1, { array: 0 }], status: [1, 0] }
+  },
   MediationResponse: {
     object: {
       decomposition_certified: [1, 0],
@@ -22204,6 +23219,7 @@ var RESPONSE_COMPONENTS = {
       variable: [1, 0]
     }
   },
+  MeterDto: { object: { used: [1, 0] } },
   MigrationPreviewEntryDto: {
     object: {
       classification: [1, 0],
@@ -22244,6 +23260,15 @@ var RESPONSE_COMPONENTS = {
       trials: [1, 0]
     }
   },
+  MiningCoverageDto: {
+    object: {
+      attributes_unextended: [1, 0],
+      beam_dropped: [1, 0],
+      concepts_dropped: [1, 0],
+      depth_limited: [1, 0],
+      exhaustive: [1, 0]
+    }
+  },
   MissingInfoDto: { object: { description: [1, 0], kind: [1, 0], priority: [1, 0] } },
   ModularArithResponse: { object: { result: [1, 0] } },
   MonadicFactDto: {
@@ -22283,7 +23308,6 @@ var RESPONSE_COMPONENTS = {
       variable: [1, 0]
     }
   },
-  NafResponse: { object: { result: [1, 0] } },
   NamespaceDto: {
     object: { id: [1, 0], name: [1, 0], path: [1, 0], tags: [1, { array: 0 }], visibility: [1, 0] }
   },
@@ -22312,6 +23336,9 @@ var RESPONSE_COMPONENTS = {
     }
   },
   NeuroSymbolicStatusResponse: { object: { enabled: [1, 0], status: [2, { object: {} }] } },
+  NextQuestionDto: {
+    object: { information_gain: [1, 0], over_candidates: [1, 0], p_yes: [1, 0], sort: [1, 0] }
+  },
   NlQueryResponse: {
     object: {
       mode: [1, 0],
@@ -22655,6 +23682,58 @@ var RESPONSE_COMPONENTS = {
       state: [1, { array: "VariableDto" }]
     }
   },
+  PatternContextResponse: {
+    object: {
+      attributes: [1, { array: 0 }],
+      engine_binary_sha256: [1, 0],
+      excluded_attributes: [0, { array: 0 }],
+      objects: [1, { array: 0 }],
+      rows: [1, { array: { array: 0 } }],
+      semantics: [1, 0],
+      snapshot_sha256: [1, 0],
+      tenant: [1, 0],
+      version: [1, 0]
+    }
+  },
+  PatternDiscoveryResponse: {
+    object: {
+      checked_proposals: [1, 0],
+      continuation: [2, { object: {} }],
+      evidence_status: [1, 0],
+      mode: [1, 0],
+      patterns: [1, { array: "PatternExplanationResponse" }],
+      proposal_verification_complete: [1, 0],
+      rejected_proposals: [1, { array: 0 }],
+      scope: [1, "PatternContextResponse"],
+      search_complete: [1, 0],
+      stop_reason: [1, 0],
+      visited: [1, 0],
+      work: [1, 0]
+    }
+  },
+  PatternExplanationResponse: {
+    object: {
+      closed_in_context: [1, 0],
+      closure: [1, { array: 0 }],
+      counterexample_count: [1, 0],
+      counterexamples: [1, { array: 0 }],
+      intent: [1, { array: 0 }],
+      scope_sha256: [1, 0],
+      semantics: [1, 0],
+      witness_count: [1, 0],
+      witnesses: [1, { array: 0 }]
+    }
+  },
+  PatternReplayResponse: {
+    object: {
+      current_scope_sha256: [1, 0],
+      evidence_status: [1, 0],
+      explanation: [2, "PatternExplanationResponse"],
+      scope_unchanged: [1, 0],
+      stale_dependencies: [1, { array: 0 }],
+      unknown_attributes: [1, { array: 0 }]
+    }
+  },
   PatternSummaryDto: {
     object: {
       base_case_inputs: [1, { array: 0 }],
@@ -22663,6 +23742,49 @@ var RESPONSE_COMPONENTS = {
       pattern_id: [1, 0]
     }
   },
+  PatternTimedDiscoveryResponse: {
+    object: {
+      checked_proposals: [1, 0],
+      continuation: [2, { object: {} }],
+      evidence_status: [1, 0],
+      mode: [1, 0],
+      patterns: [1, { array: "PatternExplanationResponse" }],
+      proposal_verification_complete: [1, 0],
+      rejected_proposals: [1, { array: 0 }],
+      scope: [1, "PatternContextResponse"],
+      search_complete: [1, 0],
+      stop_reason: [1, 0],
+      visited: [1, 0],
+      work: [1, 0],
+      timing_ms: [1, "PatternTimingResponse"]
+    }
+  },
+  PatternTimingResponse: {
+    object: {
+      model_file_io: [1, 0],
+      native_context_and_source_reads: [1, 0],
+      proposal_extraction_and_native_discovery: [1, 0],
+      request_total_before_serialization: [1, 0]
+    }
+  },
+  PatternValidationResponse: {
+    object: {
+      base_rate: [1, 0],
+      candidates: [1, { array: "ConceptRuleCandidateDto" }],
+      coverage: [2, "MiningCoverageDto"],
+      examined: [1, 0],
+      input_complete: [1, 0],
+      input_stop_reason: [1, 0],
+      installed: [1, { array: "InstalledRuleDto" }],
+      semantics: [1, 0],
+      skipped: [1, 0],
+      status: [1, 0],
+      target_feature: [1, 0],
+      validation: [2, "ConceptRuleValidationSummaryDto"],
+      candidate_source: [1, 0],
+      discovery: [1, "PatternDiscoveryResponse"]
+    }
+  },
   PauseReceipt: { object: { id: [1, 0], status: [1, 0] } },
   PendingActionReviewDto: {
     object: {
@@ -22894,6 +24016,17 @@ var RESPONSE_COMPONENTS = {
       strategy_name: [1, 0]
     }
   },
+  ProductionPlanResponse: {
+    object: {
+      feasible: [1, 0],
+      integer_profit: [1, 0],
+      integer_quantities: [1, { object: {} }],
+      quantities: [1, { object: {} }],
+      resource_utilization: [1, { object: {} }],
+      status: [1, 0],
+      total_profit: [1, 0]
+    }
+  },
   PromptTraceDto: { object: { llm_context: [1, "LlmContextTraceDto"], system_prompt: [1, 0] } },
   ProofConclusionDto: { object: { features: [1, { object: {} }], sort_id: [1, 0] } },
   ProofDto: {
@@ -23008,6 +24141,7 @@ var RESPONSE_COMPONENTS = {
       incomplete_reason: [3, 0],
       input_complete: [1, 0],
       input_stop_reason: [1, 0],
+      interpretation: [1, "DiscoveryInterpretationDto"],
       novel_concepts_discovered: [1, 0],
       processing_time_ms: [1, 0],
       recommendations: [1, { array: "SortRecommendationDto" }],
@@ -23054,6 +24188,16 @@ var RESPONSE_COMPONENTS = {
     }
   },
   PublishResponse: { object: { bundle_id: [1, 0], plugin_id: [1, 0], version: [1, 0] } },
+  PurgeAuditResponse: {
+    object: {
+      anchor: [2, "AuditAnchor"],
+      dry_run: [1, 0],
+      removed: [1, 0],
+      requested: [1, 0],
+      requested_before: [1, 0],
+      stopped_by: [2, "CutStop"]
+    }
+  },
   PushGoalResponse: { object: { goal_id: [1, 0], stack_size: [1, 0] } },
   QaPairDto: { object: { answer: [1, 0], question: [1, 0], term_id: [1, 0] } },
   QualitySummaryDto: {
@@ -23202,6 +24346,9 @@ var RESPONSE_COMPONENTS = {
   ReflectionQueryResponse: {
     object: { count: [1, 0], matches: [1, { array: 0 }], message: [1, 0] }
   },
+  RefreshSourceResponse: {
+    object: { changed: [1, 0], report: [1, "IngestUrlResponse"], source: [1, "SourceDto"] }
+  },
   RefusedEntityDto: { object: { message: [1, 0], sort_name: [1, 0], term_id: [1, 0] } },
   RefutationCheckDto: {
     object: { detail: [1, 0], name: [1, 0], passed: [1, 0], refuted_estimate: [1, 0] }
@@ -23253,6 +24400,9 @@ var RESPONSE_COMPONENTS = {
       supported_modes: [1, { array: 0 }]
     }
   },
+  RegisteredAdapterDto: {
+    object: { name: [1, 0], owned: [1, 0], platform: [1, 0], status: [1, 0] }
+  },
   ReifyTransitionsResponseDto: {
     object: {
       equations: [1, { array: 0 }],
@@ -23437,6 +24587,7 @@ var RESPONSE_COMPONENTS = {
   ResidualWitnessDto: {
     object: { partial_bindings: [1, { object: {} }], trigger: [1, 0], witness_id: [1, 0] }
   },
+  ResiduatedAntecedentDto: { object: { llr: [1, 0], sort: [1, 0] } },
   ResiduatedEntry: {
     object: {
       feature_name: [1, 0],
@@ -23510,6 +24661,7 @@ var RESPONSE_COMPONENTS = {
   RetainedOriginal: { object: { content_url: [1, 0], id: [1, 0], name: [1, 0], size: [1, 0] } },
   RetainedTableDto: { object: { reason: [1, 0], table: [1, 0] } },
   RetentionDto: { object: { enforced: [1, 0] } },
+  RetentionPolicy: { object: { legal_hold: [1, 0], min_retention_days: [1, 0] } },
   RetractRuleResponse: {
     object: { remaining_count: [1, 0], retracted_count: [1, 0], retracted_ids: [1, { array: 0 }] }
   },
@@ -23966,6 +25118,20 @@ var RESPONSE_COMPONENTS = {
       timestamp: [1, 0]
     }
   },
+  SeriesBacktestDto: { object: { holdout: [1, 0], mae: [1, 0], method: [1, 0], rmse: [1, 0] } },
+  SeriesForecastPointDto: { object: { lower: [1, 0], mean: [1, 0], step: [1, 0], upper: [1, 0] } },
+  SeriesForecastResponse: {
+    object: {
+      backtest: [1, "SeriesBacktestDto"],
+      candidates: [1, { array: "SeriesBacktestDto" }],
+      forecast: [1, { array: "SeriesForecastPointDto" }],
+      method: [1, 0],
+      observations: [1, 0],
+      parameters: [1, "SmoothingParametersDto"],
+      sigma: [1, 0],
+      skipped: [1, 0]
+    }
+  },
   SessionDocumentDto: { object: { document_id: [1, 0], status: [1, 0] } },
   SessionGraphDto: {
     object: {
@@ -24003,6 +25169,15 @@ var RESPONSE_COMPONENTS = {
   ShaclShapeDto: {
     object: { properties: [1, { array: "ShaclPropertyDto" }], target_class: [1, 0] }
   },
+  ShapleyContributionDto: { object: { coefficient: [1, 0], feature: [1, 0], value: [1, 0] } },
+  ShapleyResponse: {
+    object: {
+      baseline: [1, 0],
+      contributions: [1, { array: "ShapleyContributionDto" }],
+      intercept: [1, 0],
+      prediction: [1, 0]
+    }
+  },
   ShiftEffectResponse: {
     object: {
       assumptions: [1, { array: "CausalAssumptionDto" }],
@@ -24058,6 +25233,7 @@ var RESPONSE_COMPONENTS = {
     }
   },
   SkippedWebPageDto: { object: { depth: [1, 0], message: [1, 0], reason: [1, 0], url: [1, 0] } },
+  SmoothingParametersDto: { object: { alpha: [1, 0] } },
   SmtCheckResponse: { object: { assignments: [2, { object: {} }], result: [1, 0] } },
   SnapshotFilter: { object: { request_path_pattern: [1, 0] } },
   SnapshotResponse: {
@@ -24086,6 +25262,7 @@ var RESPONSE_COMPONENTS = {
       conclusion: [2, "ProofConclusionDto"],
       matched_sorts: [0, { array: 0 }],
       proof: [2, "ProofDto"],
+      residuated_antecedents: [0, { array: "ResiduatedAntecedentDto" }],
       residuated_sorts: [0, { array: 0 }],
       score_decomposition: [2, "LogOddsScoreDecompositionDto"],
       substitution: [1, "HomoiconicSubstitutionDto"]
@@ -24183,6 +25360,7 @@ var RESPONSE_COMPONENTS = {
       incomplete_reason: [3, 0],
       input_complete: [1, 0],
       input_stop_reason: [1, 0],
+      interpretation: [1, "DiscoveryInterpretationDto"],
       novel_concepts_discovered: [1, 0],
       processing_time_ms: [1, 0],
       recommendations: [1, { array: "SortRecommendationDto" }],
@@ -24223,6 +25401,17 @@ var RESPONSE_COMPONENTS = {
   },
   SortIndexStatusResponse: { object: { running: [1, 0], total_sorts: [1, 0] } },
   SortInfoDto: { object: { id: [1, 0] } },
+  SortLicenceResponseDto: {
+    object: {
+      declared_by: [1, 0],
+      extends: [1, 0],
+      installed_rules: [1, { array: 0 }],
+      licence_record: [1, 0],
+      policy: [1, 0],
+      sort_id: [1, 0],
+      sort_name: [1, 0]
+    }
+  },
   SortListResponse: { object: { count: [1, 0], sorts: [1, { array: "SortDto" }] } },
   SortNeighborhoodResponse: {
     object: {
@@ -24321,6 +25510,18 @@ var RESPONSE_COMPONENTS = {
       supported_modes: [1, { array: 0 }]
     }
   },
+  SourceDto: {
+    object: {
+      created_at: [1, 0],
+      id: [1, 0],
+      interval_seconds: [1, 0],
+      max_depth: [1, 0],
+      max_pages: [1, 0],
+      next_due_at: [1, 0],
+      refresh_count: [1, 0],
+      url: [1, 0]
+    }
+  },
   SourceExcerptDto: { object: { concept: [1, 0], text: [1, 0] } },
   SourceSummaryDto: {
     object: { available: [1, 0], mode: [1, 0], source_id: [1, 0], source_type: [1, 0] }
@@ -24334,6 +25535,7 @@ var RESPONSE_COMPONENTS = {
       supported_modes: [1, { array: 0 }]
     }
   },
+  SourcesResponse: { object: { sources: [1, { array: "SourceDto" }] } },
   SovereignEndpoint: { object: { host: [1, 0], internal: [1, 0], var: [1, 0] } },
   SovereigntyReport: {
     object: {
@@ -24410,6 +25612,7 @@ var RESPONSE_COMPONENTS = {
     object: {
       attribute_count: [1, 0],
       object_count: [1, 0],
+      population_sampled: [1, 0],
       question: [2, "ExplorationQuestionDto"],
       search: [1, "ExplorationSearchReportDto"],
       session_id: [1, 0]
@@ -24474,7 +25677,19 @@ var RESPONSE_COMPONENTS = {
       terms_deleted: [1, 0]
     }
   },
+  SubmitInferenceJobResponse: { object: { job_id: [1, 0], status: [1, 0], status_url: [1, 0] } },
   SubscribeToKbResponse: { object: { message: [1, 0], subscription_id: [1, 0], success: [1, 0] } },
+  SubscriptionDeliveryCountsDto: { object: { dead: [1, 0], delivered: [1, 0], pending: [1, 0] } },
+  SubscriptionDeliveryDto: {
+    object: {
+      attempts: [1, 0],
+      created_at: [1, 0],
+      id: [1, 0],
+      kind: [1, 0],
+      max_attempts: [1, 0],
+      state: [1, 0]
+    }
+  },
   SubscriptionDto: {
     object: {
       backoff_ms: [1, 0],
@@ -24531,6 +25746,13 @@ var RESPONSE_COMPONENTS = {
       verification: [1, 0]
     }
   },
+  SurvivalEffectResponse: {
+    object: {
+      censoring: [1, "CensoringDiagnosticDto"],
+      effect: [1, "AteEstimateResponse"],
+      horizon: [1, 0]
+    }
+  },
   SuspendedQueryDto: {
     object: {
       confidence: [1, 0],
@@ -24556,6 +25778,18 @@ var RESPONSE_COMPONENTS = {
       success: [1, 0]
     }
   },
+  SyntheticControlResponse: {
+    object: {
+      average_effect: [1, 0],
+      effects: [1, { array: 0 }],
+      post_rmspe: [1, 0],
+      pre_rmspe: [1, 0],
+      rmspe_ratio: [1, 0],
+      synthetic_post: [1, { array: 0 }],
+      synthetic_pre: [1, { array: 0 }],
+      weights: [1, { array: "DonorWeightDto" }]
+    }
+  },
   SystemDiagnosticCheckDto: {
     object: {
       auto_fixable: [1, 0],
@@ -24808,6 +26042,10 @@ var RESPONSE_COMPONENTS = {
   TuningDeploymentsResponse: {
     object: { deployments: [1, { array: "DeploymentDto" }], unprojectable: [1, { array: 0 }] }
   },
+  TuningExecutionDto: { object: { state: [1, 0], transaction_id: [1, 0] } },
+  TuningExecutionsResponse: {
+    object: { executions: [1, { array: "TuningExecutionDto" }], truncated: [1, 0] }
+  },
   TuningRunDto: {
     object: {
       pipeline: [1, 0],
@@ -24934,7 +26172,6 @@ var RESPONSE_COMPONENTS = {
       y: [1, 0]
     }
   },
-  UndoResponse: { object: { trail_position: [1, 0], undo_id: [1, 0] } },
   UndoRuleStoreResponse: { object: { rule_count: [1, 0], success: [1, 0] } },
   UnificationQueryResponse: { object: { count: [1, 0], results: [1, { array: "TermDto" }] } },
   UnifyBindingDto: { object: { value: [1, 0], variable: [1, 0] } },
@@ -24944,6 +26181,9 @@ var RESPONSE_COMPONENTS = {
   },
   UnsatisfiableClassDto: { object: { class: [1, 0], disjoint_pair: [1, { array: 0 }] } },
   UnsatisfiableSortDto: { object: { disjoint_pair: [1, { array: 0 }], sort: [1, 0] } },
+  UpdateAgentResponse: {
+    object: { agent_id: [1, 0], config: [1, "AgentConfigDto"], name: [1, 0] }
+  },
   UpdatePlanStatsResponse: {
     object: { message: [1, 0], new_success_rate: [1, 0], new_use_count: [1, 0] }
   },
@@ -24996,6 +26236,14 @@ var RESPONSE_COMPONENTS = {
       robots_product_token: [1, 0]
     }
   },
+  UsageLimitsDto: { object: {} },
+  UsageResponse: {
+    object: {
+      agent_cycles: [1, "MeterDto"],
+      chat_turns: [1, "MeterDto"],
+      scheduled_runs: [1, "MeterDto"]
+    }
+  },
   ValidateResponse: {
     object: {
       proof_trace: [1, "ProofTrace"],
@@ -25082,7 +26330,14 @@ var RESPONSE_COMPONENTS = {
       score: [1, 0]
     }
   },
-  VerifyResponse: { object: { n_violations: [1, 0], ok: [1, 0], violations: [1, { array: 0 }] } },
+  VerifyResponse: {
+    object: {
+      anchor: [2, "AuditAnchor"],
+      n_violations: [1, 0],
+      ok: [1, 0],
+      violations: [1, { array: 0 }]
+    }
+  },
   VerifyRoundTripResponse: {
     object: {
       entities_expected: [1, 0],
@@ -25236,6 +26491,28 @@ var RESPONSE_COMPONENTS = {
       weight: [1, 0]
     }
   },
+  WhyNotDto: {
+    object: {
+      facts_of_sort: [1, 0],
+      goal_sort: [1, 0],
+      nearest_fact: [2, "WhyNotNearestFactDto"],
+      rules: [1, { array: "WhyNotRuleDto" }],
+      summary: [1, 0]
+    }
+  },
+  WhyNotMismatchDto: { object: { expected: [1, 0], feature: [1, 0] } },
+  WhyNotNearestFactDto: {
+    object: { matched: [1, 0], mismatches: [1, { array: "WhyNotMismatchDto" }], term_id: [1, 0] }
+  },
+  WhyNotPremiseDto: { object: { features: [1, { object: {} }], sort: [1, 0] } },
+  WhyNotRuleDto: {
+    object: {
+      blocked_by: [1, { array: "WhyNotPremiseDto" }],
+      head_sort: [1, 0],
+      jointly_unsatisfied: [1, 0],
+      rule_id: [1, 0]
+    }
+  },
   WithOriginals_AsyncBatchIngestionResponse: {
     object: {
       document_count: [1, 0],
@@ -25276,6 +26553,43 @@ var RESPONSE_COMPONENTS = {
       source_revision: [1, 0]
     }
   },
+  WorkflowDto: {
+    object: {
+      created_at: [1, 0],
+      id: [1, 0],
+      inputs: [1, { array: 0 }],
+      max_steps: [1, 0],
+      name: [1, 0],
+      start: [1, 0],
+      steps: [1, { object: {} }],
+      updated_at: [1, 0],
+      version: [1, 0]
+    }
+  },
+  WorkflowListResponse: { object: { workflows: [1, { array: "WorkflowDto" }] } },
+  WorkflowRunDto: {
+    object: {
+      context: [1, { object: {} }],
+      id: [1, 0],
+      log: [1, { array: "WorkflowStepRecord" }],
+      started_at: [1, 0],
+      started_by: [1, 0],
+      status: [1, 0],
+      steps_taken: [1, 0],
+      workflow_id: [1, 0],
+      workflow_version: [1, 0]
+    }
+  },
+  WorkflowRunListResponse: { object: { runs: [1, { array: "WorkflowRunDto" }] } },
+  WorkflowStepRecord: {
+    object: {
+      finished_at: [1, 0],
+      kind: [1, 0],
+      outcome: [1, 0],
+      started_at: [1, 0],
+      step: [1, 0]
+    }
+  },
   WorldModelTransitionDto: { object: { probability: [1, 0] } },
   YankResponse: { object: { plugin_id: [1, 0], yanked: [1, 0] } }
 };
@@ -25521,21 +26835,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/vocabulary/candidates/{candidate_id}/assessments",
     responses: { 201: "AssessmentResponse" }
   },
-  assignBacktrackable: {
-    method: "POST",
-    path: "/api/v1/control/assign/backtrackable",
-    responses: { 200: "BacktrackableAssignResponse" }
-  },
   assignConceptFeatures: {
     method: "POST",
     path: "/api/v1/analysis/concept-features/assign",
     responses: { 200: "ConceptAssignmentResponseDto" }
   },
-  assignGlobal: {
-    method: "POST",
-    path: "/api/v1/control/assign/global",
-    responses: { 200: "GlobalAssignResponse" }
-  },
   assumeFeasibilityVar: {
     method: "POST",
     path: "/api/v1/feasibility/sessions/{session_id}/assumptions",
@@ -25701,11 +27005,31 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/ingest/sessions/{session_id}/documents/{document_id}/cancel",
     responses: { 200: "CancelDocumentResponse" }
   },
+  cancelInferenceJob: {
+    method: "POST",
+    path: "/api/v1/inference/jobs/{id}/cancel",
+    responses: { 200: "InferenceJobDto" }
+  },
+  cancelWorkflowRun: {
+    method: "POST",
+    path: "/api/v1/workflow-runs/{run_id}/cancel",
+    responses: { 200: "WorkflowRunDto" }
+  },
   captureSnapshot: {
     method: "POST",
     path: "/api/v1/predictions/snapshot",
     responses: { 201: "PredictionSnapshot" }
   },
+  categoricalInfer: {
+    method: "POST",
+    path: "/api/v1/inference/categorical",
+    responses: { 200: "CategoricalResult" }
+  },
+  categoricalVerify: {
+    method: "POST",
+    path: "/api/v1/inference/categorical/verify",
+    responses: { 200: "CategoricalVerifyResponse" }
+  },
   causationProbabilities: {
     method: "POST",
     path: "/api/v1/causal/causation-probabilities",
@@ -25764,11 +27088,6 @@ var RESPONSE_OPERATIONS = {
   },
   checkSmt: { method: "POST", path: "/api/v1/smt/check", responses: { 200: "SmtCheckResponse" } },
   checkTuple: { method: "POST", path: "/api/v1/authz/check", responses: { 200: "CheckResponse" } },
-  chunk: {
-    method: "PUT",
-    path: "/api/v1/ingest/rdf/uploads/{id}",
-    responses: { 200: "ChunkReceipt" }
-  },
   classify: {
     method: "POST",
     path: "/api/v1/facets/{parent}/{facet}/classify",
@@ -25855,10 +27174,19 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/facets/{parent}/{facet}/complement/{cell}",
     responses: { 200: "ComplementDto" }
   },
-  complete: {
+  completeDocumentUpload: {
     method: "POST",
-    path: "/api/v1/ingest/rdf/uploads/{id}/complete",
-    responses: { 202: "Artifact" }
+    path: "/api/v1/ingest/documents/uploads/{id}/complete",
+    responses: {
+      200: "IngestDocumentResponse",
+      201: "IngestDocumentResponse",
+      202: "WithOriginals_AsyncIngestionResponse"
+    }
+  },
+  completeDsr: {
+    method: "POST",
+    path: "/api/v1/dsr/{id}/complete",
+    responses: { 200: "DsrRecordResponse" }
   },
   completeExploration: {
     method: "POST",
@@ -25880,6 +27208,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/sorts/meet/complete",
     responses: { 200: "CompleteBoundResponse" }
   },
+  completeRdfUpload: {
+    method: "POST",
+    path: "/api/v1/ingest/rdf/uploads/{id}/complete",
+    responses: { 202: "Artifact" }
+  },
   computeCentrality: {
     method: "POST",
     path: "/api/v1/analysis/centrality",
@@ -25930,30 +27263,6 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/analysis/contrast",
     responses: { 200: "ContrastResponseDto" }
   },
-  controlCallOnce: {
-    method: "POST",
-    path: "/api/v1/control/call-once",
-    responses: { 200: "CallOnceResponse" }
-  },
-  controlCond: { method: "POST", path: "/api/v1/control/cond", responses: { 200: "CondResponse" } },
-  controlCut: { method: "POST", path: "/api/v1/control/cut", responses: { 200: "CutResponse" } },
-  controlFindall: {
-    method: "POST",
-    path: "/api/v1/control/findall",
-    responses: { 200: "FindallResponse" }
-  },
-  controlForall: {
-    method: "POST",
-    path: "/api/v1/control/forall",
-    responses: { 200: "ForallResponse" }
-  },
-  controlImplies: {
-    method: "POST",
-    path: "/api/v1/control/implies",
-    responses: { 200: "ImpliesResponse" }
-  },
-  controlNaf: { method: "POST", path: "/api/v1/control/naf", responses: { 200: "NafResponse" } },
-  controlUndo: { method: "POST", path: "/api/v1/control/undo", responses: { 200: "UndoResponse" } },
   copyTerm: { method: "POST", path: "/api/v1/copy/term", responses: { 200: "CopyTermResponse" } },
   corpusBridges: {
     method: "POST",
@@ -25985,7 +27294,6 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/audit/entries/count",
     responses: { 200: "CountAuditEntriesResponse" }
   },
-  create: { method: "POST", path: "/api/v1/ingest/rdf/uploads", responses: { 201: "Artifact" } },
   createAgent: {
     method: "POST",
     path: "/api/v1/cognitive/agents",
@@ -26032,6 +27340,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/execution/curry",
     responses: { 200: "CurriedFunctionResponse" }
   },
+  createDocumentUpload: {
+    method: "POST",
+    path: "/api/v1/ingest/documents/uploads",
+    responses: { 201: "DocumentUpload" }
+  },
   createDsr: { method: "POST", path: "/api/v1/dsr", responses: { 201: "DsrRecordResponse" } },
   createExecutionSession: {
     method: "POST",
@@ -26048,6 +27361,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/inference/goals",
     responses: { 201: "CreateGoalResponse" }
   },
+  createIngestSource: {
+    method: "POST",
+    path: "/api/v1/ingest/sources",
+    responses: { 201: "SourceDto" }
+  },
   createModule: {
     method: "POST",
     path: "/api/v1/modules",
@@ -26058,6 +27376,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/oversight/sessions",
     responses: { 201: "CreateSessionResponse" }
   },
+  createRdfUpload: {
+    method: "POST",
+    path: "/api/v1/ingest/rdf/uploads",
+    responses: { 201: "Artifact" }
+  },
   createRootNamespace: {
     method: "POST",
     path: "/api/v1/namespaces",
@@ -26109,6 +27432,7 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/proof-engine/term-store/sessions",
     responses: { 200: "TermStoreSessionResponse" }
   },
+  createWorkflow: { method: "POST", path: "/api/v1/workflows", responses: { 201: "WorkflowDto" } },
   currentFluentValue: {
     method: "GET",
     path: "/api/v1/fluents/current",
@@ -26197,6 +27521,11 @@ var RESPONSE_OPERATIONS = {
     responses: { 200: "DeleteTermReport" }
   },
   demoSeed: { method: "POST", path: "/api/v1/demo/seed", responses: { 200: "DemoSeedResponse" } },
+  denyDsr: {
+    method: "POST",
+    path: "/api/v1/dsr/{id}/deny",
+    responses: { 200: "DsrRecordResponse" }
+  },
   deprecateSort: {
     method: "POST",
     path: "/api/v1/sorts/{id}/deprecate",
@@ -26217,6 +27546,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/ui/describe",
     responses: { 200: "UIDescribeResponse" }
   },
+  detectAnomalies: {
+    method: "POST",
+    path: "/api/v1/analysis/anomalies",
+    responses: { 200: "AnomalyResponse" }
+  },
   detectCommunities: {
     method: "POST",
     path: "/api/v1/communities/detect",
@@ -26262,6 +27596,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/statistical/discover-model",
     responses: { 200: "DiscoverModelResponse" }
   },
+  discoverPatternProposals: {
+    method: "POST",
+    path: "/api/v1/analysis/pattern-proposals",
+    responses: { 200: "PatternTimedDiscoveryResponse" }
+  },
   discoverSchema: {
     method: "POST",
     path: "/api/v1/sources/{source_id}/discover",
@@ -26277,6 +27616,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/reasoning/disentailment",
     responses: { 200: "DisentailmentResponse" }
   },
+  disentailmentBatch: {
+    method: "POST",
+    path: "/api/v1/reasoning/disentailment/batch",
+    responses: { 200: "DisentailmentBatchResponse" }
+  },
   dryRun: {
     method: "POST",
     path: "/api/v1/authz/dry-run",
@@ -26377,6 +27721,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/causal/att/dml",
     responses: { 200: "AteEstimateResponse" }
   },
+  estimateCateHandler: {
+    method: "POST",
+    path: "/api/v1/causal/cate",
+    responses: { 200: "CateResponse" }
+  },
   estimateDoseResponseHandler: {
     method: "POST",
     path: "/api/v1/causal/dose-response",
@@ -26387,6 +27736,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/causal/front-door",
     responses: { 200: "FrontDoorResponse" }
   },
+  estimateLateHandler: {
+    method: "POST",
+    path: "/api/v1/causal/late",
+    responses: { 200: "LateResponse" }
+  },
   estimateMediationDmlHandler: {
     method: "POST",
     path: "/api/v1/causal/mediation/dml",
@@ -26402,11 +27756,26 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/causal/mediation/multi",
     responses: { 200: "MediationResponse" }
   },
+  estimateRegressionDiscontinuity: {
+    method: "POST",
+    path: "/api/v1/causal/rdd",
+    responses: { 200: "DiscontinuityResponse" }
+  },
   estimateShiftHandler: {
     method: "POST",
     path: "/api/v1/causal/shift",
     responses: { 200: "ShiftEffectResponse" }
   },
+  estimateSurvivalEffect: {
+    method: "POST",
+    path: "/api/v1/causal/survival",
+    responses: { 200: "SurvivalEffectResponse" }
+  },
+  estimateSyntheticControl: {
+    method: "POST",
+    path: "/api/v1/causal/synthetic-control",
+    responses: { 200: "SyntheticControlResponse" }
+  },
   evaluateArgumentation: {
     method: "POST",
     path: "/api/v1/argumentation/evaluate",
@@ -26473,21 +27842,46 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/action-reviews/expire",
     responses: { 200: "ExpireReviewsResponse" }
   },
+  explainWithShapley: {
+    method: "POST",
+    path: "/api/v1/analysis/shapley",
+    responses: { 200: "ShapleyResponse" }
+  },
   explorationStatus: {
     method: "GET",
     path: "/api/v1/analysis/attribute-exploration/{session_id}/status",
     responses: { 200: "ExplorationStatusResponseDto" }
   },
+  exportAgent: {
+    method: "GET",
+    path: "/api/v1/cognitive/agents/{agent_id}/export",
+    responses: { 200: "AgentBundle" }
+  },
+  exportDsr: {
+    method: "POST",
+    path: "/api/v1/dsr/{id}/export",
+    responses: { 200: "DsrExportResponse" }
+  },
   exportJsonl: {
     method: "POST",
     path: "/api/v1/synthetic/export-jsonl",
     responses: { 200: "ExportJsonlResponse" }
   },
+  exportPatternContext: {
+    method: "POST",
+    path: "/api/v1/analysis/pattern-proposals/context",
+    responses: { 200: "PatternContextResponse" }
+  },
   exportProof: {
     method: "POST",
     path: "/api/v1/proof/export",
     responses: { 200: "ProofExportResponse" }
   },
+  extendDsr: {
+    method: "POST",
+    path: "/api/v1/dsr/{id}/extend",
+    responses: { 200: "DsrRecordResponse" }
+  },
   extractEntities: {
     method: "POST",
     path: "/api/v1/extract/entities",
@@ -26548,6 +27942,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/forecast/{domain}",
     responses: { 200: "ForecastResponse" }
   },
+  forecastSeries: {
+    method: "POST",
+    path: "/api/v1/analysis/forecast",
+    responses: { 200: "SeriesForecastResponse" }
+  },
   forwardChain: {
     method: "POST",
     path: "/api/v1/inference/forward-chain",
@@ -26628,7 +28027,6 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/ui/generate",
     responses: { 200: "UIGenerateResponse" }
   },
-  get: { method: "GET", path: "/api/v1/ingest/rdf/uploads/{id}", responses: { 200: "Artifact" } },
   getActionReviewConfigHandler: {
     method: "GET",
     path: "/api/v1/cognitive/agents/action-review-config",
@@ -26694,6 +28092,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/compliance/audit/records/{record_id}",
     responses: { 200: "AuditRecord" }
   },
+  getAuditRetention: {
+    method: "GET",
+    path: "/api/v1/compliance/audit/retention",
+    responses: { 200: "RetentionPolicy" }
+  },
   getBindings: {
     method: "POST",
     path: "/api/v1/execution/sessions/{session_id}/bindings",
@@ -26824,12 +28227,22 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/documents/{document_id}/summary",
     responses: { 200: "DocumentSummaryResponse" }
   },
+  getDocumentUpload: {
+    method: "GET",
+    path: "/api/v1/ingest/documents/uploads/{id}",
+    responses: { 200: "DocumentUpload" }
+  },
   getDsr: { method: "GET", path: "/api/v1/dsr/{id}", responses: { 200: "DsrRecordResponse" } },
   getEgress: {
     method: "GET",
     path: "/api/v1/sovereignty/egress",
     responses: { 200: "EgressCheck" }
   },
+  getEmergencyStop: {
+    method: "GET",
+    path: "/api/v1/emergency-stop",
+    responses: { 200: "EmergencyStopStatus" }
+  },
   getEngineStats: {
     method: "GET",
     path: "/api/v1/engine/stats",
@@ -26931,6 +28344,11 @@ var RESPONSE_OPERATIONS = {
     responses: { 200: "HypergraphResponse" }
   },
   getInbox: { method: "GET", path: "/api/v1/inbox", responses: { 200: "InboxResponse" } },
+  getInferenceJob: {
+    method: "GET",
+    path: "/api/v1/inference/jobs/{id}",
+    responses: { 200: "InferenceJobDto" }
+  },
   getIngestionDocumentStats: {
     method: "GET",
     path: "/api/v1/ingest/sessions/{session_id}/documents/{document_id}/stats",
@@ -27061,6 +28479,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/sorts/quotient-order",
     responses: { 200: "GetQuotientOrderResponse" }
   },
+  getRdfUpload: {
+    method: "GET",
+    path: "/api/v1/ingest/rdf/uploads/{id}",
+    responses: { 200: "Artifact" }
+  },
   getRelease: {
     method: "GET",
     path: "/api/v1/vocabulary/releases/{release_id}",
@@ -27208,11 +28631,18 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/visualization/unify-terms",
     responses: { 200: "TermUnifyVisualizationResponse" }
   },
+  getUsage: { method: "GET", path: "/api/v1/usage", responses: { 200: "UsageResponse" } },
   getVerificationCertificate: {
     method: "GET",
     path: "/api/v1/verification/certificates/{id}",
     responses: { 200: "VerificationCertificateResponse" }
   },
+  getWorkflow: { method: "GET", path: "/api/v1/workflows/{id}", responses: { 200: "WorkflowDto" } },
+  getWorkflowRun: {
+    method: "GET",
+    path: "/api/v1/workflow-runs/{run_id}",
+    responses: { 200: "WorkflowRunDto" }
+  },
   gflownetSample: {
     method: "POST",
     path: "/api/v1/ilp/gflownet/sample",
@@ -27223,11 +28653,6 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/visualization/lattice/glb-lub-trace",
     responses: { 200: "GlbLubComputationTrace" }
   },
-  globalIncrement: {
-    method: "POST",
-    path: "/api/v1/control/global/incr",
-    responses: { 200: "GlobalIncrementResponse" }
-  },
   goalResiduation: {
     method: "POST",
     path: "/api/v1/reasoning/goal-residuation",
@@ -27269,6 +28694,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/speakers/identify",
     responses: { 200: "IdentifySpeakersResponse" }
   },
+  importAgent: {
+    method: "POST",
+    path: "/api/v1/cognitive/agents/import",
+    responses: { 201: "ImportAgentResponse" }
+  },
   importAxioms: {
     method: "POST",
     path: "/api/v1/ontology/axioms/import",
@@ -27421,15 +28851,20 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/ilp/learn",
     responses: { 200: "LearnPatternResponse" }
   },
+  learnRelationalRules: {
+    method: "POST",
+    path: "/api/v1/ilp/learn-rules",
+    responses: { 200: "LearnRulesResponse" }
+  },
   learnSortSimilarities: {
     method: "POST",
     path: "/api/v1/sorts/learn-similarities",
     responses: { 200: "LearnSortSimilaritiesResponse" }
   },
-  list: {
-    method: "GET",
-    path: "/api/v1/ingest/rdf/uploads",
-    responses: { 200: { array: "Artifact" } }
+  licenseExplorationSort: {
+    method: "POST",
+    path: "/api/v1/analysis/attribute-exploration/{session_id}/licences",
+    responses: { 200: "SortLicenceResponseDto" }
   },
   listActionTypes: {
     method: "GET",
@@ -27441,6 +28876,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/identities",
     responses: { 200: "AgentIdentityListResponse" }
   },
+  listAgentRuns: {
+    method: "GET",
+    path: "/api/v1/cognitive/agents/{agent_id}/runs",
+    responses: { 200: "AgentRunsResponse" }
+  },
   listAgents: {
     method: "GET",
     path: "/api/v1/cognitive/agents",
@@ -27536,6 +28976,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/pairing/policies",
     responses: { 200: "DmPoliciesResponse" }
   },
+  listDocumentUploads: {
+    method: "GET",
+    path: "/api/v1/ingest/documents/uploads",
+    responses: { 200: "DocumentUploadsResponse" }
+  },
   listDocumentVersions: {
     method: "GET",
     path: "/api/v1/documents/{document_id}/versions",
@@ -27561,6 +29006,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/audit/entries",
     responses: { 200: "ListAuditEntriesResponse" }
   },
+  listEpistemicEntries: {
+    method: "GET",
+    path: "/api/v1/epistemic/entries",
+    responses: { 200: "EpistemicEntriesResponse" }
+  },
   listEvalFunctions: {
     method: "POST",
     path: "/api/v1/proof-engine/eval/functions",
@@ -27601,6 +29051,16 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/ingest/sessions/{session_id}/incomplete",
     responses: { 200: "ListIncompleteDocumentsResponse" }
   },
+  listInferenceJobs: {
+    method: "GET",
+    path: "/api/v1/inference/jobs",
+    responses: { 200: "InferenceJobsResponse" }
+  },
+  listIngestSources: {
+    method: "GET",
+    path: "/api/v1/ingest/sources",
+    responses: { 200: "SourcesResponse" }
+  },
   listIngestionSessions: {
     method: "GET",
     path: "/api/v1/ingest/sessions",
@@ -27706,6 +29166,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/preferences",
     responses: { 200: "ListPreferencesResponseDto" }
   },
+  listRdfUploads: {
+    method: "GET",
+    path: "/api/v1/ingest/rdf/uploads",
+    responses: { 200: { array: "Artifact" } }
+  },
   listReasoningOperations: {
     method: "GET",
     path: "/api/v1/reasoning/operations",
@@ -27772,6 +29237,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/speakers",
     responses: { 200: "ListSpeakersResponse" }
   },
+  listSubscriptionDeliveries: {
+    method: "GET",
+    path: "/api/v1/subscriptions/{id}/deliveries",
+    responses: { 200: "ListSubscriptionDeliveriesResponse" }
+  },
   listSubscriptions: {
     method: "GET",
     path: "/api/v1/subscriptions",
@@ -27803,6 +29273,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/continual-tuning/deployments",
     responses: { 200: "TuningDeploymentsResponse" }
   },
+  listTuningExecutions: {
+    method: "GET",
+    path: "/api/v1/continual-tuning/executions",
+    responses: { 200: "TuningExecutionsResponse" }
+  },
   listTuningRuns: {
     method: "GET",
     path: "/api/v1/continual-tuning/runs",
@@ -27848,6 +29323,16 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/plugins/wasm",
     responses: { 200: { array: "WasmPluginResponse" } }
   },
+  listWorkflowRuns: {
+    method: "GET",
+    path: "/api/v1/workflows/{id}/runs",
+    responses: { 200: "WorkflowRunListResponse" }
+  },
+  listWorkflows: {
+    method: "GET",
+    path: "/api/v1/workflows",
+    responses: { 200: "WorkflowListResponse" }
+  },
   markChoicePoint: {
     method: "POST",
     path: "/api/v1/execution/sessions/{session_id}/mark",
@@ -28076,16 +29561,16 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/sorts/{id}/features/{feature}",
     responses: { 200: "SortFeatureEditResponse" }
   },
-  pause: {
-    method: "POST",
-    path: "/api/v1/ingest/rdf/uploads/{id}/pause",
-    responses: { 200: "PauseReceipt" }
-  },
   pauseAgentHandler: {
     method: "POST",
     path: "/api/v1/cognitive/agents/{agent_id}/pause",
     responses: { 200: "AgentStatusChangeResponse" }
   },
+  pauseRdfUpload: {
+    method: "POST",
+    path: "/api/v1/ingest/rdf/uploads/{id}/pause",
+    responses: { 200: "PauseReceipt" }
+  },
   planStrategies: {
     method: "POST",
     path: "/api/v1/grounded-synthesis/strategies/plan",
@@ -28161,11 +29646,26 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/marketplace/publish",
     responses: { 201: "PublishResponse" }
   },
+  purgeAuditLedger: {
+    method: "POST",
+    path: "/api/v1/compliance/audit/purge",
+    responses: { 200: "PurgeAuditResponse" }
+  },
   pushGoal: {
     method: "POST",
     path: "/api/v1/execution/sessions/{session_id}/goals",
     responses: { 200: "PushGoalResponse" }
   },
+  putAgentIdentity: {
+    method: "PUT",
+    path: "/api/v1/identities/{agent_id}",
+    responses: { 200: "AgentIdentity" }
+  },
+  putDocumentUploadChunk: {
+    method: "PUT",
+    path: "/api/v1/ingest/documents/uploads/{id}",
+    responses: { 200: "DocumentUploadChunkReceipt" }
+  },
   putHookProgram: {
     method: "PUT",
     path: "/api/v1/hook-programs/{slug}",
@@ -28233,6 +29733,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/channels/webhook",
     responses: { 200: "IncomingWebhookResponse" }
   },
+  reconcileTuningExecution: {
+    method: "POST",
+    path: "/api/v1/continual-tuning/executions/{transaction_id}/reconcile",
+    responses: { 200: "TuningExecutionDto" }
+  },
   recordEpisode: {
     method: "POST",
     path: "/api/v1/cognitive/agents/episodes",
@@ -28258,11 +29763,21 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/ingest/recover-stuck",
     responses: { 200: "RecoverStuckResponse" }
   },
+  redriveSubscriptionDelivery: {
+    method: "POST",
+    path: "/api/v1/subscriptions/{id}/deliveries/{delivery_id}/redrive",
+    responses: { 202: "SubscriptionDeliveryDto" }
+  },
   reflectionQuery: {
     method: "POST",
     path: "/api/v1/cognitive/agents/reflect",
     responses: { 200: "ReflectionQueryResponse" }
   },
+  refreshIngestSource: {
+    method: "POST",
+    path: "/api/v1/ingest/sources/{id}/refresh",
+    responses: { 200: "RefreshSourceResponse" }
+  },
   refute: { method: "POST", path: "/api/v1/ltn/refute", responses: { 200: "LtnRefuteResponse" } },
   refuteEstimate: {
     method: "POST",
@@ -28279,6 +29794,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/admin/packs/base",
     responses: { 200: "RegisterBasePackResponse" }
   },
+  registerChannelAdapter: {
+    method: "POST",
+    path: "/api/v1/channels/adapters",
+    responses: { 201: "RegisteredAdapterDto" }
+  },
   registerChannelRoute: {
     method: "POST",
     path: "/api/v1/channels/routes",
@@ -28294,6 +29814,7 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/functions/register",
     responses: { 200: "RegisterFunctionResponse" }
   },
+  registerSkill: { method: "POST", path: "/api/v1/skills", responses: { 201: "SkillSummaryDto" } },
   registerSource: {
     method: "POST",
     path: "/api/v1/sources",
@@ -28394,6 +29915,16 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/inference/rules/{id}",
     responses: { 200: "ReplaceRuleResponse" }
   },
+  replaceWorkflow: {
+    method: "PUT",
+    path: "/api/v1/workflows/{id}",
+    responses: { 200: "WorkflowDto" }
+  },
+  replayPatternExplanation: {
+    method: "POST",
+    path: "/api/v1/analysis/pattern-proposals/explanations/replay",
+    responses: { 200: "PatternReplayResponse" }
+  },
   reprocessFailedDocuments: {
     method: "POST",
     path: "/api/v1/ingest/reprocess-failed",
@@ -28666,6 +30197,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/cognitive/agents/action-review-config",
     responses: { 200: "SetActionReviewConfigResponse" }
   },
+  setAuditRetention: {
+    method: "PUT",
+    path: "/api/v1/compliance/audit/retention",
+    responses: { 200: "RetentionPolicy" }
+  },
   setCompetencyQuestionStatus: {
     method: "PATCH",
     path: "/api/v1/ontology/competency-questions/{key}",
@@ -28676,6 +30212,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/pairing/policies/{platform}/{channel_id}",
     responses: { 200: "DmPolicyDto" }
   },
+  setEmergencyStop: {
+    method: "POST",
+    path: "/api/v1/emergency-stop",
+    responses: { 200: "EmergencyStopStatus" }
+  },
   setFuzzySubsumption: {
     method: "POST",
     path: "/api/v1/sorts/subsumption",
@@ -28706,6 +30247,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/continual-tuning/kill-switch",
     responses: { 200: "KillSwitchResponse" }
   },
+  setUsageLimits: {
+    method: "PUT",
+    path: "/api/v1/usage/limits",
+    responses: { 200: "UsageLimitsDto" }
+  },
   simulateHeartbeat: {
     method: "POST",
     path: "/api/v1/heartbeat/simulate",
@@ -28726,11 +30272,17 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/flow-networks/{network_id}/solve",
     responses: { 200: "SolveFlowNetworkResponse" }
   },
+  solveMaxsat: { method: "POST", path: "/api/v1/sat/maxsat", responses: { 200: "MaxSatResponse" } },
   solveProblem: {
     method: "POST",
     path: "/api/v1/solver/solve",
     responses: { 200: "SolveProblemResponse" }
   },
+  solveProductionPlan: {
+    method: "POST",
+    path: "/api/v1/lp/production-plan",
+    responses: { 200: "ProductionPlanResponse" }
+  },
   solveSat: { method: "POST", path: "/api/v1/sat/solve", responses: { 200: "SatSolveResponse" } },
   solverHealth: {
     method: "GET",
@@ -28757,6 +30309,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/connectors/manage/{name}/connect",
     responses: { 200: "OAuthStartResponse" }
   },
+  startWorkflowRun: {
+    method: "POST",
+    path: "/api/v1/workflows/{id}/runs",
+    responses: { 201: "WorkflowRunDto" }
+  },
   stopAgentHandler: {
     method: "POST",
     path: "/api/v1/cognitive/agents/{agent_id}/stop",
@@ -28803,6 +30360,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/thomas/study",
     responses: { 200: "ThomasStudyResponse" }
   },
+  subjectEpistemicEntries: {
+    method: "GET",
+    path: "/api/v1/epistemic/subjects/{id}",
+    responses: { 200: "EpistemicEntriesResponse" }
+  },
   submitCandidate: {
     method: "POST",
     path: "/api/v1/vocabulary/candidates/{candidate_id}/submit",
@@ -28813,6 +30375,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/conversation/{id}/feedback",
     responses: { 200: "ConversationAnswerFeedbackResponseDto" }
   },
+  submitInferenceJob: {
+    method: "POST",
+    path: "/api/v1/inference/jobs",
+    responses: { 202: "SubmitInferenceJobResponse" }
+  },
   subscribeToKb: {
     method: "POST",
     path: "/api/v1/cognitive/agents/subscribe",
@@ -28962,6 +30529,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/proof-engine/term-store/sessions/{session_id}/unify",
     responses: { 200: "UnifyTermsResponse" }
   },
+  updateAgent: {
+    method: "PUT",
+    path: "/api/v1/cognitive/agents/{agent_id}",
+    responses: { 200: "UpdateAgentResponse" }
+  },
   updatePlanStats: {
     method: "POST",
     path: "/api/v1/cognitive/agents/plans/stats",
@@ -28988,6 +30560,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/marketplace/installs/{install_id}/upgrade",
     responses: { 200: "InstallResponse" }
   },
+  uploadRdfChunk: {
+    method: "PUT",
+    path: "/api/v1/ingest/rdf/uploads/{id}",
+    responses: { 200: "ChunkReceipt" }
+  },
   uploadSourceFile: {
     method: "POST",
     path: "/api/v1/sources/files",
@@ -29008,11 +30585,21 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/causal/validate-did",
     responses: { 200: "DiDValidationResponse" }
   },
+  validatePatternProposals: {
+    method: "POST",
+    path: "/api/v1/analysis/pattern-proposals/validate",
+    responses: { 200: "PatternValidationResponse" }
+  },
   validateRule: {
     method: "POST",
     path: "/api/v1/inference/rules/validate",
     responses: { 200: "RuleValidationResponse" }
   },
+  validateSnapshot: {
+    method: "POST",
+    path: "/api/v1/predictions/snapshot/{id}/validate",
+    responses: { 200: "ValidationReportDto" }
+  },
   validateStub: {
     method: "POST",
     path: "/api/v1/predictions/snapshot/{id}/validate-stub",
@@ -29038,6 +30625,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/compliance/audit/verify",
     responses: { 200: "VerifyResponse" }
   },
+  verifyDsr: {
+    method: "POST",
+    path: "/api/v1/dsr/{id}/verify",
+    responses: { 200: "DsrRecordResponse" }
+  },
   verifyFaithfulness: {
     method: "POST",
     path: "/api/v1/synthetic/verify-faithfulness",
@@ -31566,8 +33158,46 @@ function SolutionDtoFromApiToFront(dto) {
       dto.score_decomposition
     );
   }
+  if (dto.null_moment !== void 0) solution.nullMoment = dto.null_moment;
+  if (dto.residuated_antecedents !== void 0) {
+    solution.residuatedAntecedents = dto.residuated_antecedents.map((a) => {
+      const antecedent = { sort: a.sort, llr: a.llr };
+      if (a.freq !== void 0) antecedent.freq = a.freq;
+      if (a.absence !== void 0) antecedent.absence = a.absence;
+      return antecedent;
+    });
+  }
   return solution;
 }
+function WhyNotFromApiToFront(dto) {
+  return {
+    goalSort: dto.goal_sort,
+    summary: dto.summary,
+    factsOfSort: dto.facts_of_sort,
+    nearestFact: dto.nearest_fact == null ? dto.nearest_fact : {
+      termId: dto.nearest_fact.term_id,
+      matched: dto.nearest_fact.matched,
+      mismatches: dto.nearest_fact.mismatches.map((m) => ({
+        feature: m.feature,
+        expected: m.expected,
+        actual: m.actual
+      }))
+    },
+    rules: dto.rules.map((r) => ({
+      ruleId: r.rule_id,
+      headSort: r.head_sort,
+      blockedBy: r.blocked_by.map((p) => ({
+        sort: p.sort,
+        features: Object.fromEntries(
+          Object.entries(p.features).filter(
+            (entry) => entry[1] !== void 0
+          )
+        )
+      })),
+      jointlyUnsatisfied: r.jointly_unsatisfied
+    }))
+  };
+}
 function ConstraintInputDtoFromFrontToApi(model) {
   switch (model.type) {
     case "Guard":
@@ -31599,6 +33229,7 @@ function BackwardChainResponseFromApiToFront(dto) {
   if (dto.open_world_search != null) {
     out.openWorldSearch = OpenWorldSearchCompletionFromApiToFront(dto.open_world_search);
   }
+  if (dto.why_not != null) out.whyNot = WhyNotFromApiToFront(dto.why_not);
   return out;
 }
 function ForwardChainResponseFromApiToFront(dto) {
@@ -31702,6 +33333,14 @@ function FuzzyProveResponseFromApiToFront(dto) {
   if (dto.open_world_search != null) {
     out.openWorldSearch = OpenWorldSearchCompletionFromApiToFront(dto.open_world_search);
   }
+  if (dto.next_questions !== void 0) {
+    out.nextQuestions = dto.next_questions.map((q) => ({
+      sort: q.sort,
+      informationGain: q.information_gain,
+      pYes: q.p_yes,
+      overCandidates: q.over_candidates
+    }));
+  }
   return out;
 }
 function isStringRecord(value) {
@@ -32143,7 +33782,8 @@ function BackwardChainRequestFromFrontToApi(model) {
     max_solutions: model.maxSolutions,
     min_certainty: model.minCertainty,
     timeout_ms: model.timeoutMs ?? void 0,
-    constraints: model.constraints?.map(ConstraintInputDtoFromFrontToApi)
+    constraints: model.constraints?.map(ConstraintInputDtoFromFrontToApi),
+    explain_failure: model.explainFailure
   };
 }
 function ForwardChainRequestFromFrontToApi(model) {
@@ -32170,7 +33810,10 @@ function FuzzyProveRequestFromFrontToApi(model) {
     tnorm: model.tnorm,
     scope: model.scope,
     seal: model.seal,
-    kb_data_version: model.kbDataVersion
+    kb_data_version: model.kbDataVersion,
+    next_questions: model.nextQuestions,
+    asked_sorts: model.askedSorts,
+    require_scope_features: model.requireScopeFeatures
   };
 }
 function BulkFuzzyProveRequestFromFrontToApi(model) {
@@ -37792,7 +39435,15 @@ function DmlAteRequestFromFrontToApi(model) {
     learner: model.learner,
     observations: model.observations.map(ContinuousObservationDtoFromFrontToApi),
     repetitions: model.repetitions,
-    seed: model.seed
+    seed: model.seed,
+    ...model.fromKb !== void 0 ? {
+      from_kb: model.fromKb === null ? null : {
+        sort: model.fromKb.sort,
+        treatment: model.fromKb.treatment,
+        outcome: model.fromKb.outcome,
+        ...model.fromKb.covariates !== void 0 ? { covariates: model.fromKb.covariates } : {}
+      }
+    } : {}
   };
 }
 function DoublyRobustCertificateDtoFromApiToFront(dto) {
@@ -39098,6 +40749,7 @@ function IngestionConfigDtoFromFrontToApi(model) {
     enable_document_enrichment: model.enableDocumentEnrichment,
     enable_entity_filtering: model.enableEntityFiltering,
     enable_evidence_enrichment: model.enableEvidenceEnrichment,
+    enable_fca_discovery: model.enableFcaDiscovery,
     enable_focused_extraction: model.enableFocusedExtraction,
     enable_llm_coreference: model.enableLlmCoreference,
     enable_schema_discovery: model.enableSchemaDiscovery,
@@ -39294,7 +40946,26 @@ function IngestionStatsDtoFromApiToFront(dto) {
     sortsReused: dto.sorts_reused,
     sotaExtractionGate: dto.sota_extraction_gate ? SotaExtractionGateStatsDtoFromApiToFront(dto.sota_extraction_gate) : void 0,
     termIds: dto.term_ids,
-    tokenUsage: dto.token_usage ? TokenUsageDtoFromApiToFront(dto.token_usage) : void 0
+    tokenUsage: dto.token_usage ? TokenUsageDtoFromApiToFront(dto.token_usage) : void 0,
+    fcaDiscovery: dto.fca_discovery ? FcaIngestionReportFromApiToFront(dto.fca_discovery) : void 0
+  };
+}
+function FcaIngestionReportFromApiToFront(dto) {
+  return {
+    analysedTerms: dto.analysed_terms,
+    inputComplete: dto.input_complete,
+    searchComplete: dto.search_complete,
+    stopReason: dto.stop_reason,
+    conceptsEnumerated: dto.concepts_enumerated,
+    conceptsMatchingExisting: dto.concepts_matching_existing,
+    recommendations: dto.recommendations.map((r) => ({
+      sortName: r.sort_name,
+      features: r.features,
+      termCount: r.term_count,
+      confidence: r.confidence,
+      parentSort: r.parent_sort
+    })),
+    refusal: dto.refusal
   };
 }
 function ParsedDocumentMetadataDtoFromApiToFront(dto) {
@@ -41406,7 +43077,7 @@ var IngestionClient = class {
    * ```
    */
   async createRdfUpload(request, requestOptions) {
-    const response = await this.api.create(
+    const response = await this.api.createRdfUpload(
       CreateRdfUploadRequestFromFrontToApi(request),
       toRequestParams(requestOptions)
     );
@@ -41432,7 +43103,7 @@ var IngestionClient = class {
    * ```
    */
   async listRdfUploads(requestOptions) {
-    const response = await this.api.list(toRequestParams(requestOptions));
+    const response = await this.api.listRdfUploads(toRequestParams(requestOptions));
     return decodeResponse(response, (dto) => dto.map(RdfUploadFromApiToFront));
   }
   /**
@@ -41457,7 +43128,7 @@ var IngestionClient = class {
    * ```
    */
   async getRdfUpload(id, requestOptions) {
-    const response = await this.api.get(id, toRequestParams(requestOptions));
+    const response = await this.api.getRdfUpload(id, toRequestParams(requestOptions));
     return decodeResponse(response, RdfUploadFromApiToFront);
   }
   /**
@@ -41540,7 +43211,7 @@ var IngestionClient = class {
    * ```
    */
   async completeRdfUpload(id, requestOptions) {
-    const response = await this.api.complete(id, toRequestParams(requestOptions));
+    const response = await this.api.completeRdfUpload(id, toRequestParams(requestOptions));
     return decodeResponse(response, RdfUploadFromApiToFront);
   }
   /**
@@ -41568,7 +43239,7 @@ var IngestionClient = class {
    * ```
    */
   async pauseRdfUpload(id, requestOptions) {
-    const response = await this.api.pause(id, toRequestParams(requestOptions));
+    const response = await this.api.pauseRdfUpload(id, toRequestParams(requestOptions));
     return decodeResponse(response, RdfUploadPauseReceiptFromApiToFront);
   }
 };
@@ -42682,7 +44353,15 @@ function ResourceCoordinationRequestFromFrontToApi(model) {
   return {
     compatibility_threshold: model.compatibilityThreshold,
     num_selections: model.numSelections,
-    resources: model.resources.map(ResourceSpecFromFrontToApi)
+    resources: model.resources.map(ResourceSpecFromFrontToApi),
+    ...model.rules !== void 0 ? {
+      rules: model.rules.map((r) => ({
+        from: r.from,
+        from_field: r.fromField,
+        to: r.to,
+        to_field: r.toField
+      }))
+    } : {}
   };
 }
 function CoordinatedResourceSetFromApiToFront(dto) {
@@ -43459,161 +45138,6 @@ function SymbolDtoFromApiToFront(dto) {
     visibility: dto.visibility
   };
 }
-function BacktrackableAssignRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    term_id: model.termId,
-    feature_name: model.featureName,
-    new_value: AssignValueDtoFromFrontToApi(model.newValue)
-  };
-}
-function BacktrackableAssignResponseFromApiToFront(dto) {
-  return {
-    featureName: dto.feature_name,
-    previousValue: dto.previous_value ? AssignValueDtoFromApiToFront(dto.previous_value) : dto.previous_value ?? void 0,
-    termId: dto.term_id,
-    trailEntryAdded: dto.trail_entry_added
-  };
-}
-function GlobalAssignRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    variable_name: model.variableName,
-    value: AssignValueDtoFromFrontToApi(model.value)
-  };
-}
-function GlobalAssignResponseFromApiToFront(dto) {
-  return {
-    previousValue: dto.previous_value ? AssignValueDtoFromApiToFront(dto.previous_value) : dto.previous_value ?? void 0,
-    variableName: dto.variable_name
-  };
-}
-function CallOnceRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    goal: model.goal
-  };
-}
-function CallOnceResponseFromApiToFront(dto) {
-  return {
-    choicePointsCut: dto.choice_points_cut,
-    success: dto.success
-  };
-}
-function CondRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    condition: model.condition,
-    then_goal: model.thenGoal,
-    else_goal: model.elseGoal
-  };
-}
-function CondResponseFromApiToFront(dto) {
-  return {
-    branchExecuted: dto.branch_executed,
-    conditionSucceeded: dto.condition_succeeded,
-    success: dto.success
-  };
-}
-function CutRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId
-  };
-}
-function CutResponseFromApiToFront(dto) {
-  return {
-    choicePointsRemoved: dto.choice_points_removed
-  };
-}
-function FindallRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    template: model.template,
-    goal: model.goal,
-    max_solutions: model.maxSolutions
-  };
-}
-function FindallResponseFromApiToFront(dto) {
-  return {
-    count: dto.count,
-    solutions: dto.solutions
-  };
-}
-function ForallRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    generator: model.generator,
-    test: model.test
-  };
-}
-function ForallResponseFromApiToFront(dto) {
-  return {
-    result: dto.result,
-    solutionsTested: dto.solutions_tested
-  };
-}
-function GlobalGetRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    variable_name: model.variableName
-  };
-}
-function GlobalGetResponseFromApiToFront(dto) {
-  if (dto.status === "found") {
-    return {
-      status: "found",
-      value: AssignValueDtoFromApiToFront(dto.value)
-    };
-  }
-  return {
-    status: "not_found",
-    variableName: dto.variable_name
-  };
-}
-function GlobalIncrementRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    variable_name: model.variableName
-  };
-}
-function GlobalIncrementResponseFromApiToFront(dto) {
-  return {
-    newValue: dto.new_value,
-    variableName: dto.variable_name
-  };
-}
-function ImpliesRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    antecedent: model.antecedent,
-    consequent: model.consequent
-  };
-}
-function ImpliesResponseFromApiToFront(dto) {
-  return {
-    antecedentSucceeded: dto.antecedent_succeeded,
-    consequentSucceeded: dto.consequent_succeeded,
-    result: dto.result
-  };
-}
-function ControlNafRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    goal: model.goal
-  };
-}
-function UndoRequestFromFrontToApi(model) {
-  return {
-    session_id: model.sessionId,
-    goal: model.goal
-  };
-}
-function UndoResponseFromApiToFront(dto) {
-  return {
-    trailPosition: dto.trail_position,
-    undoId: dto.undo_id
-  };
-}
 function CreateModuleRequestFromFrontToApi(model) {
   return {
     name: model.name,
@@ -43702,162 +45226,6 @@ var ControlClient = class {
   constructor(api) {
     this.api = api;
   }
-  /**
-   * Perform backtrackable assignment.
-   *
-   * @param request - Assignment request with term, feature, and value.
-   * @returns Assignment result with trail entry status.
-   */
-  async backtrackableAssign(request, requestOptions) {
-    const response = await this.api.assignBacktrackable(
-      BacktrackableAssignRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, BacktrackableAssignResponseFromApiToFront);
-  }
-  /**
-   * Perform global assignment (persists across backtracking).
-   *
-   * @param request - Global assignment request.
-   * @returns Assignment result with previous value.
-   */
-  async globalAssign(request, requestOptions) {
-    const response = await this.api.assignGlobal(
-      GlobalAssignRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, GlobalAssignResponseFromApiToFront);
-  }
-  /**
-   * Execute a goal once with cut (deterministic).
-   *
-   * @param request - Call-once request with goal.
-   * @returns Result with success status and choice points cut.
-   */
-  async callOnce(request, requestOptions) {
-    const response = await this.api.controlCallOnce(
-      CallOnceRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, CallOnceResponseFromApiToFront);
-  }
-  /**
-   * Execute conditional (if-then-else).
-   *
-   * @param request - Conditional request with condition, then, and else goals.
-   * @returns Result with branch executed and success status.
-   */
-  async cond(request, requestOptions) {
-    const response = await this.api.controlCond(
-      CondRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, CondResponseFromApiToFront);
-  }
-  /**
-   * Perform Prolog-style cut (discard choice points).
-   *
-   * @param request - Cut request with session ID.
-   * @returns Number of choice points removed.
-   */
-  async cut(request, requestOptions) {
-    const response = await this.api.controlCut(
-      CutRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, CutResponseFromApiToFront);
-  }
-  /**
-   * Collect all solutions for a goal (findall).
-   *
-   * @param request - Findall request with template, goal, and optional max.
-   * @returns Collected solutions and count.
-   */
-  async findall(request, requestOptions) {
-    const response = await this.api.controlFindall(
-      FindallRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, FindallResponseFromApiToFront);
-  }
-  /**
-   * Universal quantification (forall).
-   *
-   * @param request - Forall request with generator and test goals.
-   * @returns Result and number of solutions tested.
-   */
-  async forall(request, requestOptions) {
-    const response = await this.api.controlForall(
-      ForallRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, ForallResponseFromApiToFront);
-  }
-  /**
-   * Get a global variable value.
-   *
-   * @param request - Get request with session ID and variable name.
-   * @returns The global variable value or not-found status.
-   */
-  async globalGet(request, requestOptions) {
-    const response = await this.api.globalGet(
-      GlobalGetRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, GlobalGetResponseFromApiToFront);
-  }
-  /**
-   * Increment a global counter variable.
-   *
-   * @param request - Increment request with session ID and variable name.
-   * @returns New value and variable name.
-   */
-  async globalIncrement(request, requestOptions) {
-    const response = await this.api.globalIncrement(
-      GlobalIncrementRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, GlobalIncrementResponseFromApiToFront);
-  }
-  /**
-   * Execute implies (A -> B).
-   *
-   * @param request - Implies request with antecedent and consequent.
-   * @returns Implication result.
-   */
-  async implies(request, requestOptions) {
-    const response = await this.api.controlImplies(
-      ImpliesRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, ImpliesResponseFromApiToFront);
-  }
-  /**
-   * Negation as failure (low-level control).
-   *
-   * @param request - NAF request with goal.
-   * @returns Whether the goal failed (negation succeeded).
-   */
-  async naf(request, requestOptions) {
-    const response = await this.api.controlNaf(
-      ControlNafRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, (dto) => dto);
-  }
-  /**
-   * Register an undo goal (execute on backtracking).
-   *
-   * @param request - Undo request with goal.
-   * @returns Undo ID and trail position.
-   */
-  async undo(request, requestOptions) {
-    const response = await this.api.controlUndo(
-      UndoRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
-    );
-    return decodeResponse(response, UndoResponseFromApiToFront);
-  }
   // --- Module System ---
   /**
    * Create a module.
@@ -48213,7 +49581,68 @@ function SortRegistrationFromApiToFront(dto) {
     sortName: dto.sort_name,
     created: dto.created,
     sortId: dto.sort_id,
-    error: dto.error
+    error: dto.error,
+    realizedMembers: dto.realized_members
+  };
+}
+function DiscoveryInterpretationFromApiToFront(dto) {
+  return {
+    kind: dto.kind,
+    complete: dto.complete,
+    scaledAttributeCount: dto.scaled_attribute_count,
+    unscaledValueCount: dto.unscaled_value_count,
+    truncated: dto.truncated
+  };
+}
+function ScaleSchemeFromFrontToApi(model) {
+  switch (model.kind) {
+    case "nominal":
+      return { kind: "nominal" };
+    case "interordinal":
+      return { kind: "interordinal", thresholds: model.thresholds };
+    case "prefix":
+      return {
+        kind: "prefix",
+        separator: model.separator,
+        depths: model.depths,
+        ...model.reverse !== void 0 ? { reverse: model.reverse } : {}
+      };
+    case "interval":
+      return { kind: "interval", edges: model.edges };
+  }
+}
+function DiscoverySemanticsFromFrontToApi(model) {
+  switch (model.kind) {
+    case "schema_presence":
+      return { kind: "schema_presence" };
+    case "scaled":
+      return {
+        kind: "scaled",
+        schemes: Object.fromEntries(
+          Object.entries(model.schemes).map(([feature, scheme]) => [
+            feature,
+            ScaleSchemeFromFrontToApi(scheme)
+          ])
+        ),
+        ...model.maxAttributes !== void 0 ? { max_attributes: model.maxAttributes } : {}
+      };
+    case "native_predicates":
+      return {
+        kind: "native_predicates",
+        predicates: model.predicates.map((p) => ({ name: p.name, pattern_root: p.patternRoot })),
+        ...model.alpha !== void 0 ? { alpha: model.alpha } : {},
+        ...model.version !== void 0 ? { version: model.version } : {}
+      };
+  }
+}
+function ExplorationPublicationFromApiToFront(dto) {
+  return {
+    policy: dto.policy,
+    licenceRecord: dto.licence_record,
+    populationRecord: dto.population_record,
+    scopeMembers: dto.scope_members,
+    subjectSortIds: dto.subject_sort_ids,
+    installedRules: dto.installed_rules
   };
 }
 function ExplorationSearchReportFromApiToFront(dto) {
@@ -48244,7 +49673,9 @@ function SortDiscoveryRequestFromFrontToApi(model) {
     fuzzy_thresholds: model.fuzzyThresholds,
     max_source_scan: model.maxSourceScan,
     max_visited_concepts: model.maxVisitedConcepts,
-    max_work: model.maxWork
+    max_work: model.maxWork,
+    ...model.termIds !== void 0 ? { term_ids: model.termIds } : {},
+    ...model.semantics !== void 0 ? { semantics: DiscoverySemanticsFromFrontToApi(model.semantics) } : {}
   };
 }
 function SortDiscoveryResponseFromApiToFront(dto) {
@@ -48262,6 +49693,7 @@ function SortDiscoveryResponseFromApiToFront(dto) {
     inputComplete: dto.input_complete,
     inputStopReason: dto.input_stop_reason,
     search: FcaSearchSummaryFromApiToFront(dto.search),
+    interpretation: DiscoveryInterpretationFromApiToFront(dto.interpretation),
     registrations: dto.registrations.map(SortRegistrationFromApiToFront)
   };
 }
@@ -48272,6 +49704,7 @@ function StartExplorationRequestFromFrontToApi(model) {
     min_intent_size: model.minIntentSize,
     max_terms: model.maxTerms,
     ...model.sortNames !== void 0 ? { sort_names: model.sortNames } : {},
+    ...model.semantics !== void 0 ? { semantics: DiscoverySemanticsFromFrontToApi(model.semantics) } : {},
     ...explorationSearchBoundsFromFrontToApi(model)
   };
 }
@@ -48281,7 +49714,8 @@ function StartExplorationResponseFromApiToFront(dto) {
     attributeCount: dto.attribute_count,
     objectCount: dto.object_count,
     question: dto.question ? ExplorationQuestionDtoFromApiToFront(dto.question) : dto.question,
-    search: ExplorationSearchReportFromApiToFront(dto.search)
+    search: ExplorationSearchReportFromApiToFront(dto.search),
+    populationSampled: dto.population_sampled
   };
 }
 function ConfirmResponseFromApiToFront(dto) {
@@ -48305,6 +49739,7 @@ function RefuteRequestFromFrontToApi(model) {
     question_id: model.questionId,
     label: model.label,
     features: model.features,
+    ...model.values !== void 0 ? { values: featuresFromFrontToApi(model.values) } : {},
     ...explorationSearchBoundsFromFrontToApi(model)
   };
 }
@@ -48329,7 +49764,22 @@ function ExplorationCompleteResponseFromApiToFront(dto) {
     totalImplications: dto.total_implications,
     implications: dto.implications.map(ImplicationDtoFromApiToFront),
     counterexamplesAdded: dto.counterexamples_added,
-    rulesCreated: dto.rules_created
+    rulesCreated: dto.rules_created,
+    publication: dto.publication == null ? dto.publication : ExplorationPublicationFromApiToFront(dto.publication)
+  };
+}
+function SortLicenceRequestFromFrontToApi(model) {
+  return { sort_name: model.sortName };
+}
+function SortLicenceResponseFromApiToFront(dto) {
+  return {
+    policy: dto.policy,
+    licenceRecord: dto.licence_record,
+    sortId: dto.sort_id,
+    sortName: dto.sort_name,
+    extends: dto.extends,
+    declaredBy: dto.declared_by,
+    installedRules: dto.installed_rules
   };
 }
 function ConfluenceConflictDtoFromApiToFront(dto) {
@@ -48377,26 +49827,62 @@ var AnalysisClient = class {
   /**
    * Run sort discovery analysis on existing terms.
    *
-   * @param request - Discovery parameters.
-   * @returns Discovery results with recommendations.
+   * @param request - Discovery parameters: the population (`termIds`, or the
+   *   visible terms up to `maxTerms`), the attribute `semantics`, and the
+   *   search bounds.
+   * @returns Discovery results with recommendations, the search and input
+   *   accounting, and the attribute `interpretation` used.
+   *
+   * @remarks
+   * The converted body is sent verbatim (no further key conversion): the
+   * feature names that key a `scaled` semantics' `schemes` reach the engine
+   * exactly as written. Read `success`, `inputComplete`, `search` and
+   * `interpretation.complete` before treating a missing recommendation as an
+   * absence.
    */
   async sortDiscovery(request, requestOptions) {
     const response = await this.api.analyzeSortDiscovery(
       SortDiscoveryRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
+      mergeRequestParams({ headers: { [RAW_BODY_HEADER]: "1" } }, requestOptions)
     );
     return decodeResponse(response, SortDiscoveryResponseFromApiToFront);
   }
   /**
    * Start an interactive attribute exploration session.
    *
-   * @param request - Exploration parameters.
-   * @returns Session ID and first question.
+   * @param request - Exploration parameters: the sort scope (`sortNames`),
+   *   the attribute `semantics`, and the search bounds.
+   * @param requestOptions - Per-call request options.
+   * @returns Session ID, the formal context's attribute and object counts,
+   *   the first question, and the search report.
+   * @throws {ForbiddenError} 403 with code `exploration_actor_required` when
+   *   the request carries no gateway human actor (`authenticatedUser`).
+   * @throws {BadRequestError} 400 for an unknown sort name, a refused
+   *   population bound (`exploration_population_limit`), native-predicate
+   *   semantics, or a scaled interpretation that is not complete.
+   *
+   * @remarks
+   * The converted body is sent verbatim (no further key conversion): the
+   * feature names that key a `scaled` semantics' `schemes` reach the engine
+   * exactly as written. A missing `question` does not mean the basis is
+   * complete: read `search.stop`.
+   *
+   * @example
+   * ```typescript
+   * const started = await client.analysis.startExploration({
+   *   sortNames: ['member'],
+   *   semantics: {
+   *     kind: 'scaled',
+   *     schemes: { age: { kind: 'interordinal', thresholds: [65] } },
+   *   },
+   * });
+   * console.log(started.attributeCount, started.objectCount, started.search.stop);
+   * ```
    */
   async startExploration(request, requestOptions) {
     const response = await this.api.startExploration(
       StartExplorationRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
+      mergeRequestParams({ headers: { [RAW_BODY_HEADER]: "1" } }, requestOptions)
     );
     return decodeResponse(response, StartExplorationResponseFromApiToFront);
   }
@@ -48415,6 +49901,10 @@ var AnalysisClient = class {
    *   with {@link AnalysisClient.getExplorationStatus}. The class name is the
    *   SDK's mapping of every 409: branch on the code.
    * @throws {BadRequestError} 400 when the engine refuses the content.
+   * @throws {ConstraintViolationError} 409 with code `idempotency_key_reused`
+   *   when `request.idempotencyKey` already committed a different request.
+   *   Nothing is applied; a retry of the same request with the same key
+   *   answers the committed response.
    * @throws {NotFoundError} 404 when the session does not exist.
    *
    * @remarks
@@ -48436,7 +49926,7 @@ var AnalysisClient = class {
     const response = await this.api.confirmImplication(
       sessionId,
       ConfirmRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
+      idempotencyParams2(request, requestOptions)
     );
     return decodeResponse(response, ConfirmResponseFromApiToFront);
   }
@@ -48454,10 +49944,20 @@ var AnalysisClient = class {
    *   a premise feature, has every conclusion feature, or violates a
    *   confirmed implication (it has a confirmed premise and lacks that
    *   implication's conclusion).
+   * @throws {ConstraintViolationError} 409 with code `idempotency_key_reused`
+   *   when `request.idempotencyKey` already committed a different request.
+   *   Nothing is applied; a retry of the same request with the same key
+   *   answers the committed response.
    * @throws {NotFoundError} 404 when the session does not exist.
    *
    * @remarks
-   * Body `{ question_id, label, features }`; `questionId` is required.
+   * Body `{ question_id, label, features, values? }`; `questionId` is
+   * required. A presence session takes the counterexample's feature names in
+   * `features`. A scaled session takes `features: []` and the counterexample
+   * as a record of tagged values in `values`, which the session's scales
+   * project into attributes; the engine refuses a label list or an
+   * unreadable value there with `400`, and refuses `values` in a presence
+   * session.
    *
    * The exploration continues after an answered question and poses one
    * question for each pseudo-intent, so a session asks every implication of
@@ -48470,13 +49970,20 @@ var AnalysisClient = class {
    *   label: 'penguin',
    *   features: ['bird'],
    * });
+   * // In a scaled session:
+   * await client.analysis.refuteImplication(sessionId, {
+   *   questionId: question.questionId,
+   *   label: 'young cardholder',
+   *   features: [],
+   *   values: toTaggedFeatures({ age: 30, senior_card: true }),
+   * });
    * ```
    */
   async refuteImplication(sessionId, request, requestOptions) {
     const response = await this.api.refuteImplication(
       sessionId,
       RefuteRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
+      idempotencyParams2(request, requestOptions)
     );
     return decodeResponse(response, RefuteResponseFromApiToFront);
   }
@@ -48492,6 +49999,10 @@ var AnalysisClient = class {
    * @returns The next question (absent when the search stopped again or was
    *   exhausted), the progress, and the search report.
    * @throws {BadRequestError} 400 for invalid search bounds.
+   * @throws {ConstraintViolationError} 409 with code `idempotency_key_reused`
+   *   when `request.idempotencyKey` already committed a different request.
+   *   Nothing is applied; a retry of the same request with the same key
+   *   answers the committed response.
    * @throws {NotFoundError} 404 when the session does not exist.
    *
    * @remarks
@@ -48517,7 +50028,7 @@ var AnalysisClient = class {
     const response = await this.api.advanceExploration(
       sessionId,
       AdvanceExplorationRequestFromFrontToApi(request),
-      toRequestParams(requestOptions)
+      idempotencyParams2(request, requestOptions)
     );
     return decodeResponse(response, ConfirmResponseFromApiToFront);
   }
@@ -48542,6 +50053,89 @@ var AnalysisClient = class {
     const response = await this.api.completeExploration(sessionId, toRequestParams(requestOptions));
     return decodeResponse(response, ExplorationCompleteResponseFromApiToFront);
   }
+  /**
+   * Extend a completed exploration's confirmed implications to every term of
+   * a sort and its subsorts.
+   *
+   * @param sessionId - Exploration session ID.
+   * @param request - The sort, by name.
+   * @param requestOptions - Per-call request options.
+   * @returns The `expert-declared-sort-v1` licence and the rules it installed.
+   * @throws {ConstraintViolationError} 409 with code
+   *   `exploration_session_not_completed` (the exploration is not completed)
+   *   or `exploration_not_published` (it has no recorded publication to
+   *   extend).
+   * @throws {ForbiddenError} 403 with code `exploration_actor_required` (no
+   *   gateway human actor), or when the sort is not writable.
+   * @throws {BadRequestError} 400 for an unknown sort.
+   * @throws {NotFoundError} 404 when the session is absent or not accessible.
+   * @throws {ServiceUnavailableError} 503 with code
+   *   `exploration_publication_unavailable`; nothing was installed.
+   *
+   * @remarks
+   * A separate, attributed declaration by the session's creator or an invited
+   * participant: each installed rule's obligation names the implied feature
+   * for its subject and cites a sort licence record that extends the
+   * session's frozen-population licence. No value is invented and no source
+   * term changes; licence and rules commit in one checked action. Repeating
+   * the request for the same sort returns the recorded licence.
+   *
+   * @example
+   * ```typescript
+   * const done = await client.analysis.completeExploration(sessionId);
+   * if (done.publication) {
+   *   const licence = await client.analysis.licenseExplorationSort(sessionId, { sortName: 'bird' });
+   *   console.log(licence.installedRules.length);
+   * }
+   * ```
+   */
+  async licenseExplorationSort(sessionId, request, requestOptions) {
+    const response = await this.api.licenseExplorationSort(
+      sessionId,
+      SortLicenceRequestFromFrontToApi(request),
+      toRequestParams(requestOptions)
+    );
+    return decodeResponse(response, SortLicenceResponseFromApiToFront);
+  }
+  /**
+   * Invite a gateway human user to an exploration session.
+   *
+   * @param sessionId - Exploration session ID.
+   * @param participantId - The invited user's UUID.
+   * @param requestOptions - Per-call request options.
+   * @throws {ForbiddenError} 403 without a gateway human actor, or when an
+   *   invited participant tries to delegate: only the creator may invite.
+   * @throws {NotFoundError} 404 when the session is absent or the caller has
+   *   no current invitation.
+   * @throws {ConstraintViolationError} 409 when concurrent changes exhausted
+   *   the commit attempts; retry.
+   *
+   * @remarks
+   * Repeating the same invitation is a no-op.
+   */
+  async inviteExplorationParticipant(sessionId, participantId, requestOptions) {
+    await this.api.inviteParticipant(sessionId, participantId, toRequestParams(requestOptions));
+  }
+  /**
+   * Revoke a participant's invitation to an exploration session.
+   *
+   * @param sessionId - Exploration session ID.
+   * @param participantId - The participant's UUID.
+   * @param requestOptions - Per-call request options.
+   * @throws {ForbiddenError} 403 without a gateway human actor, or when the
+   *   caller is not the creator: only the creator may revoke.
+   * @throws {NotFoundError} 404 when the session is absent or the caller has
+   *   no current invitation.
+   * @throws {ConstraintViolationError} 409 when concurrent changes exhausted
+   *   the commit attempts; retry.
+   *
+   * @remarks
+   * Repeating the same revocation is a no-op; the creator always retains
+   * access.
+   */
+  async revokeExplorationParticipant(sessionId, participantId, requestOptions) {
+    await this.api.revokeParticipant(sessionId, participantId, toRequestParams(requestOptions));
+  }
   /**
    * Certify the tenant's rule base: does forward reasoning terminate, and is
    * it order-independent?
@@ -48572,6 +50166,12 @@ var AnalysisClient = class {
     return decodeResponse(response, RuleBaseCertificateDtoFromApiToFront);
   }
 };
+function idempotencyParams2(request, requestOptions) {
+  return request.idempotencyKey === void 0 ? toRequestParams(requestOptions) : mergeRequestParams(
+    { headers: { "Idempotency-Key": request.idempotencyKey } },
+    requestOptions
+  );
+}
 
 // src/normalizers/preferences.ts
 function RecordSelectionRequestFromFrontToApi(model) {
@@ -57453,7 +59053,14 @@ function VerifyResponseFromApiToFront(dto) {
   return {
     ok: dto.ok,
     nViolations: dto.n_violations,
-    violations: dto.violations
+    violations: dto.violations,
+    anchor: dto.anchor == null ? dto.anchor : {
+      baseHash: dto.anchor.base_hash,
+      purgedCount: dto.anchor.purged_count,
+      purgedThrough: dto.anchor.purged_through,
+      purgedThroughAt: dto.anchor.purged_through_at,
+      purgeRecordId: dto.anchor.purge_record_id
+    }
   };
 }
 function CaptureSnapshotRequestFromFrontToApi(model) {
@@ -58875,6 +60482,20 @@ function ApplyActionResponseFromApiToFront(dto) {
         sideEffectsDispatched: dto.side_effects_dispatched,
         sideEffectsFailed: dto.side_effects_failed
       };
+    case "committed_execution_unavailable":
+      return {
+        outcome: "committed_execution_unavailable",
+        transactionId: dto.transaction_id,
+        reason: dto.reason,
+        retryAllowed: dto.retry_allowed
+      };
+    case "commit_unconfirmed":
+      return {
+        outcome: "commit_unconfirmed",
+        transactionId: dto.transaction_id,
+        reason: dto.reason,
+        retryAllowed: dto.retry_allowed
+      };
     case "suspended":
       return {
         outcome: "suspended",
@@ -58908,7 +60529,14 @@ var ActionsClient = class {
    *   atomic term edits to commit when the action is `Ready`.
    * @returns The outcome — `applied` (with side-effect dispatch counts),
    *   `suspended` (with the unbound required parameters), `rejected`, or
-   *   `rolled_back` (each with a reason).
+   *   `rolled_back` (each with a reason), `committed_execution_unavailable` or
+   *   `commit_unconfirmed` (each with the `transactionId` to reconcile before
+   *   any retry).
+   * @throws {ConstraintViolationError} 409 — the engine serves `rolled_back`,
+   *   `committed_execution_unavailable` and `commit_unconfirmed` with status
+   *   409, so they arrive as this error, with the wire outcome in its `body`.
+   *   Do not retry a `committed_execution_unavailable` or `commit_unconfirmed`
+   *   outcome without reconciling its transaction.
    * @throws {ApiError} 422 when an edit puts a scalar literal into a feature
    *   whose declared range is an entity sort (`Feature '<f>' holds a <kind>
    *   literal, which is incompatible with the declared range …`; write
@@ -62358,7 +63986,8 @@ function SmtCheckRequestFromFrontToApi(model) {
     clauses: model.clauses?.map((clause) => clause.map(EqLiteralDtoFromFrontToApi)),
     constants: model.constants,
     equalities: model.equalities?.map(EqualityAtomDtoFromFrontToApi),
-    functions: model.functions?.map(SmtFunctionApplicationDtoFromFrontToApi)
+    functions: model.functions?.map(SmtFunctionApplicationDtoFromFrontToApi),
+    linear: model.linear?.map((atom) => ({ id: atom.id, constraint: atom.constraint }))
   };
 }
 function SmtCheckResponseFromApiToFront(dto) {
@@ -66781,7 +68410,7 @@ var PairingClient = class {
 
 // src/normalizers/channels.ts
 function ChannelAdapterInfoFromApiToFront(dto) {
-  return { name: dto.name, platform: dto.platform, status: dto.status };
+  return { name: dto.name, platform: dto.platform, status: dto.status, owned: dto.owned };
 }
 function ListChannelAdaptersResponseFromApiToFront(dto) {
   return { adapters: dto.adapters.map(ChannelAdapterInfoFromApiToFront) };