@kortexya/reasoninglayer 6.1.0 → 7.0.0

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "6.1.0";
+var SDK_VERSION = "7.0.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -1044,6 +1044,7 @@ var REQUEST_BUDGET_HEADER = "X-RL-Request-Budget";
 function toRequestParams(options, budgetOverrides) {
   if (options === void 0 && budgetOverrides === void 0) return {};
   const headers = {};
+  if (options?.cacheControl !== void 0) headers["Cache-Control"] = options.cacheControl;
   if (options?.userId !== void 0) headers["X-User-Id"] = options.userId;
   if (options?.namespaceId !== void 0) headers["X-Namespace-Id"] = options.namespaceId;
   if (options?.causal !== void 0) Object.assign(headers, causalRequestHeaders(options.causal));
@@ -1501,6 +1502,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description ⭐ `POST /api/v1/sorts/subsumption/get` answers one pair per request, and `/sorts/compare/batch` does not close the gap: it carries an operator and a `bool`, a crisp verdict, never a degree (`docs/OPEN_DEFECTS.md` #100). ⛔ A batch is N singles and nothing else, which is why a pair naming a sort outside the caller's view refuses the WHOLE request with 404, exactly as the single route would for that pair. One HTTP response cannot carry N statuses, and answering `0.0` where the single route answers 404 would make this a different question. A caller must therefore not mix views in one batch.
+   *
+   * @tags sorts
+   * @name BatchGetSubsumptions
+   * @summary Read many `⊑·` degrees in one request, aligned with the pairs asked.
+   * @request POST:/api/v1/sorts/subsumption/get/batch
+   */
+  batchGetSubsumptions = (data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/subsumption/get/batch`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description POST /api/v1/sorts/bulk Creates multiple sorts in a single request, automatically resolving parent references by name. Sorts are topologically sorted to ensure parents are created before children. This is much faster than individual requests for large hierarchies. # Authorization Requires X-Tenant-Id header. The tenant_id field in the request body is ignored.
    *
@@ -1535,6 +1552,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description ⭐ `POST /api/v1/sorts/subsumption` writes one pair per request. Measured on a 13 199-pair graded campaign: 52 796 requests, and a 500-pair slice spent 1 200 s without finishing its sort creations (`docs/OPEN_DEFECTS.md` #100). ⛔ **Per-entry outcomes, unlike `bulk_set_similarities`** — but the two kinds of refusal differ, and conflating them would be a false promise: * a **visibility** refusal is attributed to its entry and the rest of the declaration proceeds, because that rule is this handler's and is checked per entry; * a **relation-law** refusal (a degree out of range, a disjoint facet, a max–min transitivity or antisymmetry violation) rolls the WHOLE declaration back and marks every admitted entry with one shared reason, because the kernel validates the relation once and names the violation without naming the edge. `set_count` is then 0 and nothing was written. Either way every requested entry answers for itself in the order asked, so a caller never has to re-read the batch pair by pair to learn what the engine holds — which is what `AGENTS.md` means by keeping failed evidence distinct from absent evidence. ⚠️ The discipline of the similarity route is kept exactly: both endpoints of every entry must be writable by the caller, the whole accepted batch is validated on a staging fork **before** recovery is armed or any durable prefix is written, and every written edge is mirrored into the tenant lattice every graded route reads (#113) — a bulk write that skipped the mirror would be a quieter version of that same defect.
+   *
+   * @tags sorts
+   * @name BulkSetSubsumptions
+   * @summary Declare many `⊑·` degrees in one request, answering for EVERY entry.
+   * @request POST:/api/v1/sorts/subsumption/bulk
+   */
+  bulkSetSubsumptions = (data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/subsumption/bulk`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description A unique declared minimal common supersort is answered as is. Otherwise the engine declares the synthetic join `⊔(…)` over the minimal upper bounds and places it above both operands.
    *
@@ -1599,6 +1632,22 @@ var Sorts = class {
     format: "json",
     ...params
   });
+  /**
+   * @description ⭐ One request where the pairwise route needs one per candidate: the graded relation carries a reverse adjacency, so this costs the in-degree of the concept rather than a scan of every pair. ⚠️ **Declared `⊑·` edges only** — the crisp order is not composed in, so this is not `/api/v1/sorts/subsumption/get` lifted to a set. `alpha` is a declared query parameter; the kernel refuses it outside `[0, 1]` and that refusal surfaces as `400`. ⛔ Every member is filtered against the caller's view before it is returned. The in-memory adapter already fails closed; the hot-lattice adapter cannot (absence there is not evidence of another tenant's ownership), so the filter here is what makes the route safe on both.
+   *
+   * @tags sorts
+   * @name DeclaredAlphaCutBelow
+   * @summary The α-cut of the declared graded cone below a concept, strongest first.
+   * @request POST:/api/v1/sorts/subsumption/alpha-cut
+   */
+  declaredAlphaCutBelow = (data, params = {}) => this.http.request({
+    path: `/api/v1/sorts/subsumption/alpha-cut`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * @description Computes the bit-vector intersection (GLB) and decodes it into a human-readable type disjunction. This is Life1.0's decode() function. A read (#522): a pair with no declared common subsort decodes to ⊥. # Returns - `sort_ids`: List of sort IDs in the disjunction - `sort_names`: List of sort names in the disjunction - `formatted`: Human-readable format (e.g., "int | real") - `is_bottom`: True if the GLB is empty (incompatible sorts)
    *
@@ -1669,11 +1718,11 @@ var Sorts = class {
     ...params
   });
   /**
-   * @description Formal Concept Analysis over sort × feature declaration, each declaration taken whole (name, range or type, constraint, requiredness, bound): every set of at least `min_sorts` sorts sharing at least two identical declarations is a candidate mixin. Deterministic; never writes. Accepting a proposal is creating the mixin (as a `proposed` sort) and re-parenting the members — the caller's decision: `POST /api/v1/scenarios/materialize` with the mixin and each member naming it as a parent does both, the moves going through the governed door of `POST /api/v1/sorts/{id}/parents`. A declaration a sort restates identically to an ancestor's is factored already and is never proposed again.
+   * @description Never writes. Search exhaustion concerns the stated tenant/policy cohort; presentation can truncate independently. Accepting a candidate still requires the existing governed declaration and reparenting operations. Neither this report nor its digest is an admission seal.
    *
    * @tags sorts
    * @name FactorSortShapes
-   * @summary Propose mixin parents for shapes several sorts repeat unchanged
+   * @summary Propose mixin parents using checked native FCA over whole declarations.
    * @request POST:/api/v1/sorts/discovery/factor
    * @secure
    */
@@ -8511,6 +8560,24 @@ var Constraints = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Unlike `POST /api/v1/constraints/solve`, which propagates and suspends, this route **searches**: it branches over the declared domains with propagation at every node, so a satisfiable problem yields assignments rather than a list of suspended constraints. An unsatisfiable problem answers `200` with `satisfiable: false` and no solutions; that is an answer, not a bad request.
+   *
+   * @tags constraints
+   * @name SolveCsp
+   * @summary Label a finite-domain constraint problem, returning complete assignments.
+   * @request POST:/api/v1/csp/solve
+   * @secure
+   */
+  solveCsp = (data, params = {}) => this.http.request({
+    path: `/api/v1/csp/solve`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Reasoning.ts
@@ -9408,6 +9475,21 @@ var Namespaces = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags namespaces
+   * @name GetNamespaceAnswerCachePolicy
+   * @request GET:/api/v1/namespaces/{id}/answer-cache-policy
+   * @secure
+   */
+  getNamespaceAnswerCachePolicy = (id, params = {}) => this.http.request({
+    path: `/api/v1/namespaces/${id}/answer-cache-policy`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -9456,6 +9538,23 @@ var Namespaces = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags namespaces
+   * @name UpdateNamespaceAnswerCachePolicy
+   * @request PUT:/api/v1/namespaces/{id}/answer-cache-policy
+   * @secure
+   */
+  updateNamespaceAnswerCachePolicy = (id, data, params = {}) => this.http.request({
+    path: `/api/v1/namespaces/${id}/answer-cache-policy`,
+    method: "PUT",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -9783,6 +9882,22 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Computes the concepts of the population's schema-presence context under the declared bounds and, when asked, its observed implication basis; the export carries the incidence, the bounds and each result's completeness so an importer can replay all of it.
+   *
+   * @tags analysis
+   * @name ExportFca
+   * @summary Export the FCA of an explicit population.
+   * @request POST:/api/v1/analysis/fca-exports
+   */
+  exportFca = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/fca-exports`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -10017,6 +10132,21 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The first line names the objects (source term identities) and attributes (feature names); each concept line gives its extent and intent as indices into them; the last line gives the counters, whether the stream is complete and, when it stopped early, the continuation that resumes it.
+   *
+   * @tags analysis
+   * @name StreamFcaConcepts
+   * @summary Stream the formal concepts of a visible scope as NDJSON.
+   * @request POST:/api/v1/analysis/fca-concepts/stream
+   */
+  streamFcaConcepts = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/fca-concepts/stream`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    ...params
+  });
   /**
    * No description
    *
@@ -10032,6 +10162,22 @@ var Analysis = class {
     format: "json",
     ...params
   });
+  /**
+   * @description Replays the export natively: decodes its context, recomputes a graded incidence from its degrees and cut, recomputes its concepts and basis under its declared bounds, and requires each claim, completeness included, to equal its recomputation; every object must name a source term of the caller's tenant. A refusal accepts nothing and names its reason.
+   *
+   * @tags analysis
+   * @name VerifyFcaExport
+   * @summary Verify an FCA export for import into the caller's tenant.
+   * @request POST:/api/v1/analysis/fca-exports/verify
+   */
+  verifyFcaExport = (data, params = {}) => this.http.request({
+    path: `/api/v1/analysis/fca-exports/verify`,
+    method: "POST",
+    body: data,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
 };
 
 // src/api-spec/generated/Functions.ts
@@ -11397,7 +11543,7 @@ var Ontology = class {
     ...params
   });
   /**
-   * @description Every metric is derived from the tenant's live lattice and term store. The state of a stage comes from a scoped assessment only; no stage is accepted because of its counts. The vocabulary stage's evidence is the governed vocabulary store. When that store cannot be read, the whole status is refused (`503`) rather than served with the stage degraded: reporting `not_assessed` for a tenant that may hold an active release would state something the engine does not know.
+   * @description Every metric is derived from the tenant's live lattice and term store, or from the active governed vocabulary release when that release is the stage's basis. The state of a stage comes from a scoped assessment only; no stage is accepted because of its counts. The evidence of the vocabulary, taxonomy and thesaurus stages is the governed vocabulary store: the active release and the criteria results of the assessment it cites. When that store cannot be read, the whole status is refused (`503`) rather than served with the stages degraded: reporting `not_assessed` for a tenant that may hold an active release would state something the engine does not know.
    *
    * @tags ontology
    * @name OntologyPipelineStatus
@@ -16331,6 +16477,24 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name ApplyMigrationPlan
+   * @summary `POST /api/v1/vocabulary/migration/plans/{plan_id}/apply` — apply a plan as a new candidate on the active release; `409 migration_plan_stale` when the legacy inventory changed since the plan.
+   * @request POST:/api/v1/vocabulary/migration/plans/{plan_id}/apply
+   * @secure
+   */
+  applyMigrationPlan = (planId, data, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/migration/plans/${planId}/apply`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -16367,6 +16531,41 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name CommitImport
+   * @summary `POST /api/v1/vocabulary/imports/{import_id}/commit` — apply the reviewer's decisions and write one candidate revision: a new candidate, or revision n+1 of `candidate_id` (with `If-Match`).
+   * @request POST:/api/v1/vocabulary/imports/{import_id}/commit
+   * @secure
+   */
+  commitImport = (importId, data, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/imports/${importId}/commit`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name ConceptExpansion
+   * @summary `GET /api/v1/vocabulary/concepts/{concept_id}/expansion` — the concepts a query on one concept may be expanded to, each with its support.
+   * @request GET:/api/v1/vocabulary/concepts/{concept_id}/expansion
+   * @secure
+   */
+  conceptExpansion = (conceptId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/concepts/${conceptId}/expansion`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -16383,6 +16582,23 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name ConceptRelations
+   * @summary `GET /api/v1/vocabulary/concepts/{concept_id}/relations` — the direct relations of one kind of a concept in one scheme, of every status.
+   * @request GET:/api/v1/vocabulary/concepts/{concept_id}/relations
+   * @secure
+   */
+  conceptRelations = (conceptId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/concepts/${conceptId}/relations`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -16401,6 +16617,76 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name CreateImport
+   * @summary `POST /api/v1/vocabulary/imports` — parse an uploaded source file and store its proposal. Writes no vocabulary record.
+   * @request POST:/api/v1/vocabulary/imports
+   * @secure
+   */
+  createImport = (data, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/imports`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name CreateMigrationPlan
+   * @summary `POST /api/v1/vocabulary/migration/plans` — store the reviewer's dispositions of legacy sorts over the current legacy inventory.
+   * @request POST:/api/v1/vocabulary/migration/plans
+   * @secure
+   */
+  createMigrationPlan = (data, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/migration/plans`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name ExportNative
+   * @summary `GET /api/v1/vocabulary/exports/native` — the view's records as `kos-json/v1`.
+   * @request GET:/api/v1/vocabulary/exports/native
+   * @secure
+   */
+  exportNative = (query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/exports/native`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name ExportSkos
+   * @summary `GET /api/v1/vocabulary/exports/skos` — the SKOS projection of one scheme as Turtle or RDF/XML, with its manifest.
+   * @request GET:/api/v1/vocabulary/exports/skos
+   * @secure
+   */
+  exportSkos = (query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/exports/skos`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -16466,6 +16752,38 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name GetImport
+   * @summary `GET /api/v1/vocabulary/imports/{import_id}` — an import.
+   * @request GET:/api/v1/vocabulary/imports/{import_id}
+   * @secure
+   */
+  getImport = (importId, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/imports/${importId}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name GetMigrationPlan
+   * @summary `GET /api/v1/vocabulary/migration/plans/{plan_id}` — a plan.
+   * @request GET:/api/v1/vocabulary/migration/plans/{plan_id}
+   * @secure
+   */
+  getMigrationPlan = (planId, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/migration/plans/${planId}`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -16498,6 +16816,40 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name GetVocabularyCollection
+   * @summary `GET /api/v1/vocabulary/collections/{collection_id}` — one collection with its labels, its member occurrences and its nested collections.
+   * @request GET:/api/v1/vocabulary/collections/{collection_id}
+   * @secure
+   */
+  getVocabularyCollection = (collectionId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/collections/${collectionId}`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name ImportItems
+   * @summary `GET /api/v1/vocabulary/imports/{import_id}/items` — the items of an import by ordinal, each with its coordinates, disposition, reason and target.
+   * @request GET:/api/v1/vocabulary/imports/{import_id}/items
+   * @secure
+   */
+  importItems = (importId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/imports/${importId}/items`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -16584,6 +16936,23 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name ListVocabularyCollections
+   * @summary `GET /api/v1/vocabulary/collections` — the collections of one scheme.
+   * @request GET:/api/v1/vocabulary/collections
+   * @secure
+   */
+  listVocabularyCollections = (query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/collections`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -16740,6 +17109,91 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name SchemeHierarchy
+   * @summary `GET /api/v1/vocabulary/schemes/{scheme_id}/hierarchy` — the `broader` links of one scheme around a concept, or below its top concepts.
+   * @request GET:/api/v1/vocabulary/schemes/{scheme_id}/hierarchy
+   * @secure
+   */
+  schemeHierarchy = (schemeId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/schemes/${schemeId}/hierarchy`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name SchemePaths
+   * @summary `GET /api/v1/vocabulary/schemes/{scheme_id}/paths` — the simple paths of accepted `broader` links from a narrower concept up to a broader one.
+   * @request GET:/api/v1/vocabulary/schemes/{scheme_id}/paths
+   * @secure
+   */
+  schemePaths = (schemeId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/schemes/${schemeId}/paths`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name SchemePicklist
+   * @summary `GET /api/v1/vocabulary/schemes/{scheme_id}/picklist` — the scheme's concepts depth first, for a form control.
+   * @request GET:/api/v1/vocabulary/schemes/{scheme_id}/picklist
+   * @secure
+   */
+  schemePicklist = (schemeId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/schemes/${schemeId}/picklist`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name SchemePolicy
+   * @summary `GET /api/v1/vocabulary/schemes/{scheme_id}/policy` — the scheme's taxonomy policy, or the `taxonomy-policy/v1` defaults (#611 P3-D04) with `declared: false`.
+   * @request GET:/api/v1/vocabulary/schemes/{scheme_id}/policy
+   * @secure
+   */
+  schemePolicy = (schemeId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/schemes/${schemeId}/policy`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name SchemeTopConcepts
+   * @summary `GET /api/v1/vocabulary/schemes/{scheme_id}/top-concepts` — the concepts with an accepted membership in the scheme marked `top_concept`.
+   * @request GET:/api/v1/vocabulary/schemes/{scheme_id}/top-concepts
+   * @secure
+   */
+  schemeTopConcepts = (schemeId, query, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/schemes/${schemeId}/top-concepts`,
+    method: "GET",
+    query,
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -16757,6 +17211,24 @@ var Vocabulary = class {
     format: "json",
     ...params
   });
+  /**
+   * No description
+   *
+   * @tags vocabulary
+   * @name SparqlQuery
+   * @summary `POST /api/v1/vocabulary/sparql` — one read-only SPARQL query over the SKOS projection of one scheme of one view.
+   * @request POST:/api/v1/vocabulary/sparql
+   * @secure
+   */
+  sparqlQuery = (data, params = {}) => this.http.request({
+    path: `/api/v1/vocabulary/sparql`,
+    method: "POST",
+    body: data,
+    secure: true,
+    type: "application/json",
+    format: "json",
+    ...params
+  });
   /**
    * No description
    *
@@ -17542,7 +18014,8 @@ function SortListResponseFromApiToFront(dto) {
     sorts: dto.sorts.map(SortDtoFromApiToFront),
     count: dto.count,
     total: dto.total,
-    offset: dto.offset
+    offset: dto.offset,
+    ontologyRevision: dto.ontology_revision
   };
 }
 function ListSortsQueryFromFrontToApi(query) {
@@ -17889,27 +18362,150 @@ function DeprecateSortRequestFromFrontToApi(model) {
   if (model.replacement !== void 0) out.replacement = model.replacement;
   return out;
 }
+function FactorLimitsFromFrontToApi(model) {
+  const out = {};
+  if (model.maxSorts !== void 0) out.max_sorts = model.maxSorts;
+  if (model.maxContextSorts !== void 0) out.max_context_sorts = model.maxContextSorts;
+  if (model.maxParentEdges !== void 0) out.max_parent_edges = model.maxParentEdges;
+  if (model.maxDeclarations !== void 0) out.max_declarations = model.maxDeclarations;
+  if (model.maxAttributes !== void 0) out.max_attributes = model.maxAttributes;
+  if (model.maxInputBytes !== void 0) out.max_input_bytes = model.maxInputBytes;
+  if (model.maxConcepts !== void 0) out.max_concepts = model.maxConcepts;
+  if (model.maxVisitedConcepts !== void 0) out.max_visited_concepts = model.maxVisitedConcepts;
+  if (model.maxWork !== void 0) out.max_work = model.maxWork;
+  if (model.maxProposals !== void 0) out.max_proposals = model.maxProposals;
+  if (model.maxOutputBytes !== void 0) out.max_output_bytes = model.maxOutputBytes;
+  return out;
+}
 function FactorSortsRequestFromFrontToApi(model) {
   const out = {};
   if (model.sortIds !== void 0) out.sort_ids = model.sortIds;
   if (model.minSorts !== void 0) out.min_sorts = model.minSorts;
+  if (model.limits !== void 0) {
+    out.limits = model.limits === null ? null : FactorLimitsFromFrontToApi(model.limits);
+  }
   return out;
 }
-function FactorSharedFeatureFromApiToFront(dto) {
-  const out = { name: dto.name, required: dto.required };
-  if (dto.expected_sort != null) out.expectedSort = dto.expected_sort;
-  if (dto.expected_type_hint != null) out.expectedTypeHint = dto.expected_type_hint;
-  if (dto.constraint != null) out.constraint = ConstraintDtoFromApiToFront(dto.constraint);
+function FactorLimitsFromApiToFront(dto) {
+  const out = {};
+  if (dto.max_sorts != null) out.maxSorts = dto.max_sorts;
+  if (dto.max_context_sorts != null) out.maxContextSorts = dto.max_context_sorts;
+  if (dto.max_parent_edges != null) out.maxParentEdges = dto.max_parent_edges;
+  if (dto.max_declarations != null) out.maxDeclarations = dto.max_declarations;
+  if (dto.max_attributes != null) out.maxAttributes = dto.max_attributes;
+  if (dto.max_input_bytes != null) out.maxInputBytes = dto.max_input_bytes;
+  if (dto.max_concepts != null) out.maxConcepts = dto.max_concepts;
+  if (dto.max_visited_concepts != null) out.maxVisitedConcepts = dto.max_visited_concepts;
+  if (dto.max_work != null) out.maxWork = dto.max_work;
+  if (dto.max_proposals != null) out.maxProposals = dto.max_proposals;
+  if (dto.max_output_bytes != null) out.maxOutputBytes = dto.max_output_bytes;
   return out;
 }
-function FactorSortsResponseFromApiToFront(dto) {
+function FactorSharedFeatureFromApiToFront(dto) {
   return {
+    ...FeatureDescriptorDtoFromApiToFront(dto),
+    signature: dto.signature,
+    declaredBy: dto.declared_by
+  };
+}
+function isJsonValue2(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "object";
+}
+function isFactorRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function factorStringList(value, field) {
+  if (!Array.isArray(value)) throw new TypeError(`factor context: ${field} is not an array`);
+  const items = value;
+  return items.map((item) => {
+    if (typeof item !== "string")
+      throw new TypeError(`factor context: ${field} holds a non-string`);
+    return item;
+  });
+}
+function factorNumberList(value, field) {
+  if (!Array.isArray(value)) throw new TypeError(`factor context: ${field} is not an array`);
+  const items = value;
+  return items.map((item) => {
+    if (typeof item !== "number")
+      throw new TypeError(`factor context: ${field} holds a non-number`);
+    return item;
+  });
+}
+function factorString(record, key, field) {
+  const value = Reflect.get(record, key);
+  if (typeof value !== "string")
+    throw new TypeError(`factor context: ${field}.${key} is not a string`);
+  return value;
+}
+function FactorContextFromApiToFront(value) {
+  if (!isFactorRecord(value)) throw new TypeError("factor context is not an object");
+  const sorts = Reflect.get(value, "sorts");
+  if (!Array.isArray(sorts)) throw new TypeError("factor context: sorts is not an array");
+  const snapshot = Reflect.get(value, "incidence");
+  if (!isFactorRecord(snapshot)) throw new TypeError("factor context: incidence is not an object");
+  const version = Reflect.get(snapshot, "version");
+  if (typeof version !== "number") {
+    throw new TypeError("factor context: incidence.version is not a number");
+  }
+  const rows = Reflect.get(snapshot, "incidence");
+  if (!Array.isArray(rows))
+    throw new TypeError("factor context: incidence.incidence is not an array");
+  const rowList = rows;
+  const sortList = sorts;
+  return {
+    version: factorString(value, "version", "context"),
+    tenant: factorString(value, "tenant", "context"),
+    policySha256: factorString(value, "policy_sha256", "context"),
+    sorts: sortList.map((sort) => {
+      if (!isJsonValue2(sort)) throw new TypeError("factor context: sorts holds a non-JSON value");
+      return sort;
+    }),
+    incidence: {
+      version,
+      objects: factorStringList(Reflect.get(snapshot, "objects"), "incidence.objects"),
+      attributes: factorStringList(Reflect.get(snapshot, "attributes"), "incidence.attributes"),
+      incidence: rowList.map((row) => factorNumberList(row, "incidence.incidence"))
+    }
+  };
+}
+function FactorSortsResponseFromApiToFront(dto) {
+  const out = {
+    version: dto.version,
     proposals: dto.proposals.map((p) => ({
       memberSorts: p.member_sorts.map((m) => ({ id: m.id, name: m.name })),
       sharedFeatures: p.shared_features.map(FactorSharedFeatureFromApiToFront),
-      suggestedName: p.suggested_name
-    }))
+      suggestedName: p.suggested_name,
+      extent: p.extent,
+      intent: p.intent
+    })),
+    inputComplete: dto.input_complete,
+    limits: FactorLimitsFromApiToFront(dto.limits),
+    minSorts: dto.min_sorts,
+    nativeAdmission: dto.native_admission
   };
+  if (dto.input_stop != null) {
+    out.inputStop = {
+      reason: dto.input_stop.reason,
+      resource: dto.input_stop.resource,
+      limit: dto.input_stop.limit
+    };
+  }
+  if (dto.search != null) {
+    out.search = {
+      complete: dto.search.complete,
+      stopReason: dto.search.stop_reason,
+      visitedConcepts: dto.search.visited_concepts,
+      work: dto.search.work,
+      emittedConcepts: dto.search.emitted_concepts
+    };
+  }
+  if (dto.presentation_stop_reason != null) {
+    out.presentationStopReason = dto.presentation_stop_reason;
+  }
+  if (dto.context_sha256 != null) out.contextSha256 = dto.context_sha256;
+  if (dto.context != null) out.context = FactorContextFromApiToFront(dto.context);
+  return out;
 }
 function PatchSortRequestFromFrontToApi(model) {
   const out = {};
@@ -18700,6 +19296,9 @@ var RESPONSE_COMPONENTS = {
   },
   BaselineDto: { object: { snapshot_hash: [1, 0], stale: [1, 0] } },
   BatchCopyResponse: { object: { copies: [1, { array: "CopyResultDto" }] } },
+  BatchGetSubsumptionsResponse: {
+    object: { degrees: [1, { array: "GetFuzzySubsumptionResponse" }] }
+  },
   BatchOperationResultDto: { object: { duration_ms: [1, 0], index: [1, 0], success: [1, 0] } },
   BatchResponse: {
     object: {
@@ -18893,7 +19492,11 @@ var RESPONSE_COMPONENTS = {
   },
   BulkRowRefusalDto: { object: { index: [1, 0], message: [1, 0] } },
   BulkSetSimilaritiesResponse: { object: { errors: [0, { array: 0 }], set_count: [1, 0] } },
+  BulkSetSubsumptionsResponse: {
+    object: { outcomes: [1, { array: "BulkSubsumptionOutcome" }], set_count: [1, 0] }
+  },
   BulkSortError: { object: { error: [1, 0], kind: [1, 0], name: [1, 0], sort_created: [1, 0] } },
+  BulkSubsumptionOutcome: { object: { sub_sort_id: [1, 0], sup_sort_id: [1, 0], written: [1, 0] } },
   BundleBelief: {
     object: { confidence: [1, 0], features: [0, { object: {} }], sort: [1, 0], source: [1, 0] }
   },
@@ -19449,6 +20052,16 @@ var RESPONSE_COMPONENTS = {
       verdicts: [1, { array: 0 }]
     }
   },
+  CollectionDetailResponse: {
+    object: {
+      collection: [1, "CollectionRecordDto"],
+      context: [2, "ContextRefDto"],
+      labels: [1, { array: "CollectionLabelViewDto" }],
+      members: [1, { array: "CollectionMemberViewDto" }],
+      nested_collections: [1, { array: 0 }],
+      view: [1, "ViewRefDto"]
+    }
+  },
   CollectionDto: {
     object: {
       depth: [1, 0],
@@ -19458,10 +20071,42 @@ var RESPONSE_COMPONENTS = {
       tags: [1, { array: 0 }]
     }
   },
+  CollectionLabelViewDto: {
+    object: { collection_label_id: [1, 0], label_id: [1, 0], role: [1, 0] }
+  },
   CollectionListResponse: {
     object: { collections: [1, { array: "CollectionDto" }], count: [1, 0] }
   },
+  CollectionMemberViewDto: {
+    object: { display_label: [2, "DisplayLabelDto"], occurrence_id: [1, 0] }
+  },
+  CollectionPageResponse: {
+    object: {
+      complete: [1, 0],
+      context: [2, "ContextRefDto"],
+      items: [1, { array: "CollectionSummaryDto" }],
+      scheme_id: [1, 0],
+      view: [1, "ViewRefDto"]
+    }
+  },
+  CollectionRecordDto: {
+    object: {
+      change_reason: [1, 0],
+      ordered: [1, 0],
+      record_id: [1, 0],
+      revision: [1, 0],
+      scheme: [1, 0],
+      status: [1, 0]
+    }
+  },
   CollectionResponse: { object: { collection: [1, "CollectionDto"] } },
+  CollectionSummaryDto: {
+    object: {
+      collection: [1, "CollectionRecordDto"],
+      labels: [1, { array: "CollectionLabelViewDto" }],
+      member_count: [1, 0]
+    }
+  },
   CommunitiesResponseDto: {
     object: {
       communities: [1, { array: 0 }],
@@ -19603,6 +20248,16 @@ var RESPONSE_COMPONENTS = {
       term_versions: [1, { array: "TermVersionEntryDto" }]
     }
   },
+  ConceptMappingRecordDto: {
+    object: {
+      change_reason: [1, 0],
+      mapping_kind: [1, 0],
+      record_id: [1, 0],
+      revision: [1, 0],
+      status: [1, 0],
+      subject: [1, 0]
+    }
+  },
   ConceptMatchDto: {
     object: {
       canonical_name: [1, 0],
@@ -19625,6 +20280,37 @@ var RESPONSE_COMPONENTS = {
   ConceptRecordDto: {
     object: { change_reason: [1, 0], record_id: [1, 0], revision: [1, 0], status: [1, 0] }
   },
+  ConceptRelationEntryDto: {
+    object: {
+      concept_id: [1, 0],
+      display_label: [2, "DisplayLabelDto"],
+      relation: [1, 0],
+      relation_id: [1, 0],
+      status: [1, 0]
+    }
+  },
+  ConceptRelationRecordDto: {
+    object: {
+      change_reason: [1, 0],
+      object: [1, 0],
+      record_id: [1, 0],
+      relation: [1, 0],
+      revision: [1, 0],
+      scheme: [1, 0],
+      status: [1, 0],
+      subject: [1, 0]
+    }
+  },
+  ConceptRelationsResponse: {
+    object: {
+      concept_id: [1, 0],
+      context: [2, "ContextRefDto"],
+      relation: [1, 0],
+      relations: [1, { array: "ConceptRelationEntryDto" }],
+      scheme_id: [1, 0],
+      view: [1, "ViewRefDto"]
+    }
+  },
   ConceptReleaseDto: {
     object: { record_etag: [1, 0], release_id: [1, 0], release_number: [1, 0] }
   },
@@ -19675,14 +20361,21 @@ var RESPONSE_COMPONENTS = {
     object: {
       aboutness: [1, { array: "AboutnessRecordDto" }],
       authority_references: [1, { array: "AuthorityReferenceRecordDto" }],
+      collections: [1, { array: 0 }],
       concept: [1, "ConceptRecordDto"],
       definition_guidance: [1, "DefinitionGuidanceDto"],
       definitions: [1, { array: "DefinitionRecordDto" }],
       display_label: [2, "DisplayLabelDto"],
+      documentation: [1, { array: "DocumentationRecordDto" }],
       evidence: [1, { array: "EvidenceViewDto" }],
       identity_decisions: [1, { array: "IdentityDecisionRecordDto" }],
       labels: [1, { array: "LabelUseViewDto" }],
-      memberships: [1, { array: "MembershipViewDto" }]
+      mappings: [1, { array: "ConceptMappingRecordDto" }],
+      memberships: [1, { array: "MembershipViewDto" }],
+      notations: [1, { array: "NotationRecordDto" }],
+      relations: [1, { array: "ConceptRelationRecordDto" }],
+      source_associations: [1, { array: "SourceAssociationRecordDto" }],
+      xl_labels: [1, { array: "XlLabelRecordDto" }]
     }
   },
   ConditionalIndependenceResponse: { object: { explanation: [1, 0], independent: [1, 0] } },
@@ -20058,6 +20751,19 @@ var RESPONSE_COMPONENTS = {
   CronJobRunDto: { object: { origin: [1, 0], run_id: [1, 0], started_at: [1, 0], status: [1, 0] } },
   CronScheduleDto: { object: { schedule_type: [1, 0], value: [1, 0] } },
   CrossCuttingResponseDto: { object: { items: [1, { array: 0 }], scope_truncated: [1, 0] } },
+  CspSolveResponse: {
+    object: {
+      backtracks: [1, 0],
+      nodes_explored: [1, 0],
+      propagations: [1, 0],
+      propagator_invocations: [1, 0],
+      satisfiable: [1, 0],
+      search_exhausted: [1, 0],
+      solutions: [1, { array: { object: {} } }],
+      solve_time_ms: [1, 0],
+      total_found: [1, 0]
+    }
+  },
   CuriosityTargetDto: {
     object: { exploration_priority: [1, 0], novelty: [1, 0], target_id: [1, 0] }
   },
@@ -20100,6 +20806,7 @@ var RESPONSE_COMPONENTS = {
     object: {
       actions_executed: [1, { array: 0 }],
       goals_achieved: [1, { array: 0 }],
+      goals_deferred: [0, { array: 0 }],
       goals_failed: [1, { array: 0 }],
       goals_pursued: [1, { array: 0 }],
       new_beliefs: [1, { array: 0 }],
@@ -20184,6 +20891,15 @@ var RESPONSE_COMPONENTS = {
     }
   },
   DeclareLatentVariableResponse: { object: { declared: [1, 0], variable: [1, 0] } },
+  DeclaredAlphaCutMember: { object: { degree: [1, 0], sort_id: [1, 0] } },
+  DeclaredAlphaCutResponse: {
+    object: {
+      alpha: [1, 0],
+      concept_sort_id: [1, 0],
+      members: [1, { array: "DeclaredAlphaCutMember" }],
+      strict: [1, 0]
+    }
+  },
   DeclaredEgress: { object: { host: [1, 0], purpose: [1, 0] } },
   DecodeGlbResponse: {
     object: {
@@ -20707,6 +21423,7 @@ var RESPONSE_COMPONENTS = {
       document_id: [1, 0],
       entities_extracted: [1, 0],
       entities_refused: [1, { array: "RefusedEntityDto" }],
+      fca_discovery: [2, "FcaIngestionReportDto"],
       processing_time_ms: [1, 0],
       relations_extracted: [1, 0],
       relations_integrated: [1, 0],
@@ -20749,6 +21466,9 @@ var RESPONSE_COMPONENTS = {
   DocumentVersionsResponse: {
     object: { family_id: [1, 0], versions: [1, { array: "DocumentDto" }] }
   },
+  DocumentationRecordDto: {
+    object: { change_reason: [1, 0], note_kind: [1, 0], record_id: [1, 0], revision: [1, 0] }
+  },
   DonorWeightDto: { object: { name: [1, 0], weight: [1, 0] } },
   DoseResponseResponse: {
     object: {
@@ -21095,6 +21815,30 @@ var RESPONSE_COMPONENTS = {
   ExecutionSessionStatsResponse: {
     object: { curried_function_count: [1, 0], db_available: [1, 0], memory_session_count: [1, 0] }
   },
+  ExpandedConceptDto: {
+    object: {
+      concept_id: [1, 0],
+      display_label: [2, "DisplayLabelDto"],
+      support: [1, { array: 0 }]
+    }
+  },
+  ExpandedExternalDto: {
+    object: { external_concept_id: [1, 0], iri: [1, 0], support: [1, { array: 0 }] }
+  },
+  ExpansionResponse: {
+    object: {
+      complete: [1, 0],
+      concept_id: [1, 0],
+      concepts: [1, { array: "ExpandedConceptDto" }],
+      context: [2, "ContextRefDto"],
+      direction: [1, 0],
+      external_concepts: [1, { array: "ExpandedExternalDto" }],
+      scheme_id: [1, 0],
+      transitive: [1, 0],
+      view: [1, "ViewRefDto"],
+      withheld_relation_ids: [1, { array: 0 }]
+    }
+  },
   ExpireReviewsResponse: { object: { escalated: [1, { array: 0 }], timed_out: [1, { array: 0 }] } },
   ExplorationCompleteResponseDto: {
     object: {
@@ -21273,16 +22017,47 @@ var RESPONSE_COMPONENTS = {
       present: [1, 0]
     }
   },
+  FactorInputStopDto: { object: { reason: [1, 0] } },
+  FactorLimitsDto: { object: {} },
   FactorMemberSortDto: { object: { id: [1, 0], name: [1, 0] } },
   FactorProposalDto: {
     object: {
+      extent: [1, { array: 0 }],
+      intent: [1, { array: 0 }],
       member_sorts: [1, { array: "FactorMemberSortDto" }],
       shared_features: [1, { array: "FactorSharedFeatureDto" }],
       suggested_name: [1, 0]
     }
   },
-  FactorSharedFeatureDto: { object: { name: [1, 0], required: [1, 0] } },
-  FactorSortsResponse: { object: { proposals: [1, { array: "FactorProposalDto" }] } },
+  FactorSearchDto: {
+    object: {
+      complete: [1, 0],
+      emitted_concepts: [1, 0],
+      stop_reason: [1, 0],
+      visited_concepts: [1, 0],
+      work: [1, 0]
+    }
+  },
+  FactorSharedFeatureDto: {
+    object: {
+      annotations: [0, { object: {} }],
+      name: [1, 0],
+      declared_by: [1, { array: 0 }],
+      signature: [1, 0]
+    }
+  },
+  FactorSortsResponse: {
+    object: {
+      input_complete: [1, 0],
+      input_stop: [2, "FactorInputStopDto"],
+      limits: [1, "FactorLimitsDto"],
+      min_sorts: [1, 0],
+      native_admission: [1, 0],
+      proposals: [1, { array: "FactorProposalDto" }],
+      search: [2, "FactorSearchDto"],
+      version: [1, 0]
+    }
+  },
   FactoryResetResponse: {
     object: {
       cache_cleared: [1, 0],
@@ -21297,6 +22072,50 @@ var RESPONSE_COMPONENTS = {
     }
   },
   FailedReviewDto: { object: { reason: [1, 0], review_id: [1, 0] } },
+  FcaBasisClaimDto: {
+    object: {
+      complete: [1, 0],
+      implications: [1, { array: "FcaImplicationRecordDto" }],
+      max_candidates: [3, 0],
+      max_work: [3, 0]
+    }
+  },
+  FcaConceptClaimDto: {
+    object: {
+      complete: [1, 0],
+      concepts: [1, { array: "FcaConceptRecordDto" }],
+      max_concepts: [3, 0],
+      max_visited_concepts: [3, 0],
+      max_work: [3, 0],
+      min_extent_size: [1, 0],
+      min_intent_size: [1, 0]
+    }
+  },
+  FcaConceptRecordDto: { object: { extent: [1, { array: 0 }], intent: [1, { array: 0 }] } },
+  FcaContextDto: {
+    object: {
+      attributes: [1, { array: 0 }],
+      incidence: [1, { array: { array: 0 } }],
+      objects: [1, { array: 0 }],
+      version: [1, 0]
+    }
+  },
+  FcaExportDto: {
+    object: {
+      basis: [2, "FcaBasisClaimDto"],
+      concepts: [1, "FcaConceptClaimDto"],
+      context: [1, "FcaContextDto"],
+      graded: [2, "FcaGradedIncidenceDto"],
+      version: [1, 0]
+    }
+  },
+  FcaGradedDegreeDto: { object: { attribute: [1, 0], degree: [1, 0] } },
+  FcaGradedIncidenceDto: {
+    object: { alpha: [1, 0], degrees: [1, { array: { array: "FcaGradedDegreeDto" } }] }
+  },
+  FcaImplicationRecordDto: {
+    object: { conclusion: [1, { array: 0 }], premise: [1, { array: 0 }] }
+  },
   FcaIngestionRecommendationDto: {
     object: {
       confidence: [1, 0],
@@ -21840,6 +22659,40 @@ var RESPONSE_COMPONENTS = {
   HiddenToolDto: {
     object: { name: [1, 0], quality: [1, 0], reason: [1, 0], required_quality: [1, 0] }
   },
+  HierarchyEdgeDto: {
+    object: { object: [1, 0], relation_id: [1, 0], status: [1, 0], subject: [1, 0] }
+  },
+  HierarchyNodeDto: {
+    object: {
+      concept_id: [1, 0],
+      depth: [1, 0],
+      display_label: [2, "DisplayLabelDto"],
+      via: [1, { array: 0 }]
+    }
+  },
+  HierarchyPathsResponse: {
+    object: {
+      complete: [1, 0],
+      context: [2, "ContextRefDto"],
+      from: [1, 0],
+      paths: [1, { array: { array: 0 } }],
+      scheme_id: [1, 0],
+      to: [1, 0],
+      view: [1, "ViewRefDto"]
+    }
+  },
+  HierarchyResponse: {
+    object: {
+      complete: [1, 0],
+      context: [2, "ContextRefDto"],
+      direction: [1, 0],
+      edges: [1, { array: "HierarchyEdgeDto" }],
+      nodes: [1, { array: "HierarchyNodeDto" }],
+      scheme_id: [1, 0],
+      transitive: [1, 0],
+      view: [1, "ViewRefDto"]
+    }
+  },
   HoldoutCertifiedDto: {
     object: {
       certified: [1, 0],
@@ -21988,6 +22841,7 @@ var RESPONSE_COMPONENTS = {
       sorts_created: [1, 0]
     }
   },
+  ImportCellNoteDto: { object: { column: [1, 0], disposition: [1, 0], reason: [1, 0] } },
   ImportFoundryResponse: {
     object: {
       mapped_interface_types: [1, 0],
@@ -22006,9 +22860,11 @@ var RESPONSE_COMPONENTS = {
     object: {
       reified_sorts_created: [1, { array: 0 }],
       relations_discovered: [1, 0],
-      sorts_created: [1, { array: 0 }]
+      sorts_created: [1, { array: 0 }],
+      sorts_refused: [0, { array: "ImportRefusedSortDto" }]
     }
   },
+  ImportRefusedSortDto: { object: { name: [1, 0], reason: [1, 0] } },
   InboxItemDto: {
     object: {
       body: [1, 0],
@@ -22382,6 +23238,15 @@ var RESPONSE_COMPONENTS = {
       term_id: [1, 0]
     }
   },
+  IriChoiceDto: {
+    object: {
+      iri: [1, 0],
+      kind: [1, 0],
+      record_id: [1, 0],
+      rule: [1, 0],
+      source_associations: [1, { array: 0 }]
+    }
+  },
   IriRepairDto: { object: { original: [1, 0], repaired: [1, 0] } },
   IsSubtypeResponse: { object: { is_subtype: [1, 0] } },
   IterationMetricDto: {
@@ -22630,6 +23495,19 @@ var RESPONSE_COMPONENTS = {
   LedgerInfoDto: {
     object: { backend: [1, 0], durability: [1, 0], n_records: [1, 0], survives_restart: [1, 0] }
   },
+  LegacySortInventoryDto: {
+    object: {
+      bound_constraint_count: [1, 0],
+      classification: [1, 0],
+      feature_count: [1, 0],
+      features_ranging_over: [1, 0],
+      instances: [1, 0],
+      parents: [1, { array: 0 }],
+      rules_referencing: [1, 0],
+      sort_id: [1, 0],
+      sort_name: [1, 0]
+    }
+  },
   LggClassResponseDto: {
     object: {
       absent_from_store: [1, 0],
@@ -23220,6 +24098,18 @@ var RESPONSE_COMPONENTS = {
     }
   },
   MeterDto: { object: { used: [1, 0] } },
+  MigrationPlanResponse: {
+    object: {
+      byte_size: [1, 0],
+      created_at: [1, 0],
+      created_by: [1, 0],
+      dispositions: [1, { array: "PlannedDispositionDto" }],
+      fingerprint: [1, 0],
+      inventory: [1, { array: "LegacySortInventoryDto" }],
+      plan_id: [1, 0],
+      replayed: [1, 0]
+    }
+  },
   MigrationPreviewEntryDto: {
     object: {
       classification: [1, 0],
@@ -23308,11 +24198,33 @@ var RESPONSE_COMPONENTS = {
       variable: [1, 0]
     }
   },
+  NamespaceAnswerCachePolicyDto: {
+    object: { enabled: [1, 0], revision: [1, 0], ttl_seconds: [1, 0] }
+  },
   NamespaceDto: {
     object: { id: [1, 0], name: [1, 0], path: [1, 0], tags: [1, { array: 0 }], visibility: [1, 0] }
   },
   NamespaceListResponse: { object: { count: [1, 0], namespaces: [1, { array: "NamespaceDto" }] } },
   NamespaceResponse: { object: { namespace: [1, "NamespaceDto"] } },
+  NativeExportManifestDto: {
+    object: {
+      context_manifest: [2, "ContextManifestDto"],
+      counts_by_kind: [1, { object: {} }],
+      record_count: [1, 0],
+      records_sha256: [1, 0],
+      unreadable: [1, { array: "UnreadableRecordDto" }]
+    }
+  },
+  NativeExportResponse: {
+    object: {
+      artifacts: [1, { array: "SourceArtifactRecordDto" }],
+      context: [2, "ContextRefDto"],
+      format: [1, 0],
+      manifest: [1, "NativeExportManifestDto"],
+      records: [1, { array: 0 }],
+      view: [1, "ViewRefDto"]
+    }
+  },
   NearMiss: {
     object: {
       byte_end: [1, 0],
@@ -23351,6 +24263,9 @@ var RESPONSE_COMPONENTS = {
   },
   NlQueryResultItem: { object: { features: [1, { object: {} }], id: [1, 0], sort_name: [1, 0] } },
   NodeScoreDto: { object: { node_id: [1, 0], score: [1, 0] } },
+  NotationRecordDto: {
+    object: { concept: [1, 0], record_id: [1, 0], scheme: [1, 0], value: [1, 0] }
+  },
   NumberToStringResponse: { object: { result: [1, 0] } },
   OAuthStartResponse: { object: { auth_url: [1, 0] } },
   ObjectTypeDto: {
@@ -23844,6 +24759,25 @@ var RESPONSE_COMPONENTS = {
     }
   },
   PersonalityTrait: { object: { description: [1, 0], name: [1, 0], strength: [1, 0] } },
+  PicklistEntryDto: {
+    object: {
+      concept_id: [1, 0],
+      depth: [1, 0],
+      display_label: [2, "DisplayLabelDto"],
+      other_parent_relation_ids: [1, { array: 0 }]
+    }
+  },
+  PicklistResponse: {
+    object: {
+      complete: [1, 0],
+      context: [2, "ContextRefDto"],
+      entries: [1, { array: "PicklistEntryDto" }],
+      roots: [1, { array: 0 }],
+      roots_from: [1, 0],
+      scheme_id: [1, 0],
+      view: [1, "ViewRefDto"]
+    }
+  },
   PipelineQualityStatsDto: {
     object: {
       axioms_deduplicated: [1, 0],
@@ -23897,6 +24831,7 @@ var RESPONSE_COMPONENTS = {
       total_requested: [1, 0]
     }
   },
+  PlannedDispositionDto: { object: { disposition: [1, 0], rationale: [1, 0], sort_id: [1, 0] } },
   PlannedStrategyDto: { object: { allocated: [1, 0], name: [1, 0], weight: [1, 0] } },
   PluginBindingDto: {
     object: {
@@ -24027,6 +24962,7 @@ var RESPONSE_COMPONENTS = {
       total_profit: [1, 0]
     }
   },
+  ProjectionLossDto: { object: { kind: [1, 0], reason: [1, 0], record_ids: [1, { array: 0 }] } },
   PromptTraceDto: { object: { llm_context: [1, "LlmContextTraceDto"], system_prompt: [1, 0] } },
   ProofConclusionDto: { object: { features: [1, { object: {} }], sort_id: [1, 0] } },
   ProofDto: {
@@ -24326,6 +25262,7 @@ var RESPONSE_COMPONENTS = {
       timestamp: [1, 0]
     }
   },
+  ReconciliationEntryDto: { object: { kind: [1, 0], proposal: [1, 0], source_key: [1, 0] } },
   RecordChangeDto: {
     object: { feature_changes: [1, { array: "RecordFeatureChangeDto" }], record_id: [1, 0] }
   },
@@ -25233,6 +26170,26 @@ var RESPONSE_COMPONENTS = {
     }
   },
   SkippedWebPageDto: { object: { depth: [1, 0], message: [1, 0], reason: [1, 0], url: [1, 0] } },
+  SkosExportResponse: {
+    object: {
+      content: [1, 0],
+      manifest: [1, "SkosManifestDto"],
+      media_type: [1, 0],
+      sha256: [1, 0]
+    }
+  },
+  SkosManifestDto: {
+    object: {
+      include_provenance: [1, 0],
+      iri_policy: [1, 0],
+      iris: [1, { array: "IriChoiceDto" }],
+      losses: [1, { array: "ProjectionLossDto" }],
+      projection: [1, 0],
+      scheme_id: [1, 0],
+      triple_count: [1, 0],
+      view: [1, "ViewRefDto"]
+    }
+  },
   SmoothingParametersDto: { object: { alpha: [1, 0] } },
   SmtCheckResponse: { object: { assignments: [2, { object: {} }], result: [1, 0] } },
   SnapshotFilter: { object: { request_path_pattern: [1, 0] } },
@@ -25501,6 +26458,25 @@ var RESPONSE_COMPONENTS = {
       schema_rejected_missing_source_span: [1, 0]
     }
   },
+  SourceArtifactRecordDto: {
+    object: {
+      byte_size: [1, 0],
+      dataset: [1, 0],
+      format: [1, 0],
+      record_id: [1, 0],
+      retained_locator: [1, 0],
+      sha256: [1, 0]
+    }
+  },
+  SourceAssociationRecordDto: {
+    object: {
+      artifact: [1, 0],
+      change_reason: [1, 0],
+      record_id: [1, 0],
+      revision: [1, 0],
+      source_key: [1, 0]
+    }
+  },
   SourceDetailResponse: {
     object: {
       available: [1, 0],
@@ -25546,6 +26522,14 @@ var RESPONSE_COMPONENTS = {
     }
   },
   SpaceResponse: { object: { constraint_count: [1, 0], id: [1, 0], status: [1, 0] } },
+  SparqlDatasetDto: {
+    object: {
+      projection: [1, 0],
+      scheme_id: [1, 0],
+      triple_count: [1, 0],
+      view: [1, "ViewRefDto"]
+    }
+  },
   SparqlExplainDto: {
     object: {
       complete: [1, 0],
@@ -25568,6 +26552,14 @@ var RESPONSE_COMPONENTS = {
       sorts: [0, { array: 0 }]
     }
   },
+  SparqlResponse: {
+    object: {
+      complete: [1, 0],
+      dataset: [1, "SparqlDatasetDto"],
+      form: [1, 0],
+      results: [1, { object: {} }]
+    }
+  },
   SparqlUpdateExplainDto: { object: { osfql: [1, { array: 0 }] } },
   SpeakerDetectionDto: {
     object: {
@@ -25830,6 +26822,18 @@ var RESPONSE_COMPONENTS = {
     }
   },
   TaskDto: { object: { is_primitive: [1, 0], subtasks: [1, { array: 0 }], task_id: [1, 0] } },
+  TaxonomyPolicyResponse: {
+    object: {
+      acyclic: [1, 0],
+      context: [2, "ContextRefDto"],
+      declared: [1, 0],
+      policy: [1, 0],
+      require_placement: [1, 0],
+      scheme_id: [1, 0],
+      top_concepts: [1, 0],
+      view: [1, "ViewRefDto"]
+    }
+  },
   TemporalModelCheckResponse: {
     object: {
       counterexample: [2, "CounterExampleDto"],
@@ -25973,6 +26977,14 @@ var RESPONSE_COMPONENTS = {
     }
   },
   ToolCallInfo: { object: { arguments: [1, 0], confidence: [1, 0], name: [1, 0] } },
+  TopConceptsResponse: {
+    object: {
+      concepts: [1, { array: "ConceptSummaryDto" }],
+      context: [2, "ContextRefDto"],
+      scheme_id: [1, 0],
+      view: [1, "ViewRefDto"]
+    }
+  },
   TraceStepDto: {
     object: {
       entropy: [1, 0],
@@ -26179,6 +27191,7 @@ var RESPONSE_COMPONENTS = {
   UnknownClusterDto: {
     object: { cluster: [1, 0], spans: [1, { array: "SpeechSpanDto" }], speech_secs: [1, 0] }
   },
+  UnreadableRecordDto: { object: { reason: [1, 0], record_id: [1, 0] } },
   UnsatisfiableClassDto: { object: { class: [1, 0], disjoint_pair: [1, { array: 0 }] } },
   UnsatisfiableSortDto: { object: { disjoint_pair: [1, { array: 0 }], sort: [1, 0] } },
   UpdateAgentResponse: {
@@ -26312,6 +27325,9 @@ var RESPONSE_COMPONENTS = {
     }
   },
   VerificationStepDto: { object: { description: [1, 0], name: [1, 0], passed: [1, 0] } },
+  VerifiedFcaImportDto: {
+    object: { concepts: [1, 0], concepts_complete: [1, 0], sources: [1, { array: 0 }] }
+  },
   VerifyClaimResponse: {
     object: {
       contradicting_count: [1, 0],
@@ -26412,6 +27428,40 @@ var RESPONSE_COMPONENTS = {
       subjects: [1, { array: 0 }]
     }
   },
+  VocabularyImportArtifactDto: {
+    object: { byte_size: [1, 0], format: [1, 0], sha256: [1, 0], source_file_id: [1, 0] }
+  },
+  VocabularyImportItemDto: {
+    object: {
+      coordinates: [1, { object: {} }],
+      disposition: [1, 0],
+      item: [1, { object: {} }],
+      notes: [1, { array: "ImportCellNoteDto" }],
+      ordinal: [1, 0],
+      resource_keys: [1, { array: 0 }]
+    }
+  },
+  VocabularyImportItemsResponse: {
+    object: {
+      complete: [1, 0],
+      import_id: [1, 0],
+      items: [1, { array: "VocabularyImportItemDto" }]
+    }
+  },
+  VocabularyImportResponse: {
+    object: {
+      artifact: [1, "VocabularyImportArtifactDto"],
+      complete: [1, 0],
+      counts: [1, { object: {} }],
+      created_at: [1, 0],
+      created_by: [1, 0],
+      dataset: [1, 0],
+      import_id: [1, 0],
+      proposed_record_counts: [1, { object: {} }],
+      reconciliation: [1, { array: "ReconciliationEntryDto" }],
+      replayed: [1, 0]
+    }
+  },
   VocabularyMatch: {
     object: {
       canonical: [1, 0],
@@ -26510,7 +27560,8 @@ var RESPONSE_COMPONENTS = {
       blocked_by: [1, { array: "WhyNotPremiseDto" }],
       head_sort: [1, 0],
       jointly_unsatisfied: [1, 0],
-      rule_id: [1, 0]
+      rule_id: [1, 0],
+      undetermined: [0, { array: "WhyNotPremiseDto" }]
     }
   },
   WithOriginals_AsyncBatchIngestionResponse: {
@@ -26591,6 +27642,18 @@ var RESPONSE_COMPONENTS = {
     }
   },
   WorldModelTransitionDto: { object: { probability: [1, 0] } },
+  XlLabelRecordDto: {
+    object: {
+      change_reason: [1, 0],
+      concept: [1, 0],
+      label: [1, 0],
+      record_id: [1, 0],
+      resource_key: [1, 0],
+      revision: [1, 0],
+      role: [1, 0],
+      scheme: [1, 0]
+    }
+  },
   YankResponse: { object: { plugin_id: [1, 0], yanked: [1, 0] } }
 };
 var RESPONSE_OPERATIONS = {
@@ -26780,6 +27843,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/causal/intervention",
     responses: { 200: "InterventionResponse" }
   },
+  applyMigrationPlan: {
+    method: "POST",
+    path: "/api/v1/vocabulary/migration/plans/{plan_id}/apply",
+    responses: { 201: "CandidateRevisionResponse" }
+  },
   applySnapshot: {
     method: "POST",
     path: "/api/v1/admin/snapshots/{snapshot_id}/apply/{target_tenant_id}",
@@ -26875,6 +27943,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/copy/batch",
     responses: { 200: "BatchCopyResponse" }
   },
+  batchGetSubsumptions: {
+    method: "POST",
+    path: "/api/v1/sorts/subsumption/get/batch",
+    responses: { 200: "BatchGetSubsumptionsResponse" }
+  },
   bayesianPredict: {
     method: "POST",
     path: "/api/v1/inference/bayesian-predict",
@@ -26990,6 +28063,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/sorts/similarity/bulk",
     responses: { 200: "BulkSetSimilaritiesResponse" }
   },
+  bulkSetSubsumptions: {
+    method: "POST",
+    path: "/api/v1/sorts/subsumption/bulk",
+    responses: { 200: "BulkSetSubsumptionsResponse" }
+  },
   calibrateConformal: {
     method: "POST",
     path: "/api/v1/conformal/calibrate",
@@ -27154,6 +28232,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/flow-networks/{network_id}/commit",
     responses: { 200: "FlowNetworkResponse" }
   },
+  commitImport: {
+    method: "POST",
+    path: "/api/v1/vocabulary/imports/{import_id}/commit",
+    responses: { 201: "CandidateRevisionResponse" }
+  },
   commitSpace: {
     method: "POST",
     path: "/api/v1/spaces/{space_id}/commit",
@@ -27238,11 +28321,21 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/analysis/path",
     responses: { 200: "PathResponse" }
   },
+  conceptExpansion: {
+    method: "GET",
+    path: "/api/v1/vocabulary/concepts/{concept_id}/expansion",
+    responses: { 200: "ExpansionResponse" }
+  },
   conceptHistory: {
     method: "GET",
     path: "/api/v1/vocabulary/concepts/{concept_id}/history",
     responses: { 200: "ConceptHistoryResponse" }
   },
+  conceptRelations: {
+    method: "GET",
+    path: "/api/v1/vocabulary/concepts/{concept_id}/relations",
+    responses: { 200: "ConceptRelationsResponse" }
+  },
   configureOrchestrator: {
     method: "POST",
     path: "/api/v1/inference/orchestrator/configure",
@@ -27361,11 +28454,21 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/inference/goals",
     responses: { 201: "CreateGoalResponse" }
   },
+  createImport: {
+    method: "POST",
+    path: "/api/v1/vocabulary/imports",
+    responses: { 201: "VocabularyImportResponse" }
+  },
   createIngestSource: {
     method: "POST",
     path: "/api/v1/ingest/sources",
     responses: { 201: "SourceDto" }
   },
+  createMigrationPlan: {
+    method: "POST",
+    path: "/api/v1/vocabulary/migration/plans",
+    responses: { 201: "MigrationPlanResponse" }
+  },
   createModule: {
     method: "POST",
     path: "/api/v1/modules",
@@ -27449,6 +28552,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/causal/latent-variables",
     responses: { 201: "DeclareLatentVariableResponse" }
   },
+  declaredAlphaCutBelow: {
+    method: "POST",
+    path: "/api/v1/sorts/subsumption/alpha-cut",
+    responses: { 200: "DeclaredAlphaCutResponse" }
+  },
   decodeGlb: {
     method: "POST",
     path: "/api/v1/sorts/glb/decode",
@@ -27862,11 +28970,21 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/dsr/{id}/export",
     responses: { 200: "DsrExportResponse" }
   },
+  exportFca: {
+    method: "POST",
+    path: "/api/v1/analysis/fca-exports",
+    responses: { 200: "FcaExportDto" }
+  },
   exportJsonl: {
     method: "POST",
     path: "/api/v1/synthetic/export-jsonl",
     responses: { 200: "ExportJsonlResponse" }
   },
+  exportNative: {
+    method: "GET",
+    path: "/api/v1/vocabulary/exports/native",
+    responses: { 200: "NativeExportResponse" }
+  },
   exportPatternContext: {
     method: "POST",
     path: "/api/v1/analysis/pattern-proposals/context",
@@ -27877,6 +28995,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/proof/export",
     responses: { 200: "ProofExportResponse" }
   },
+  exportSkos: {
+    method: "GET",
+    path: "/api/v1/vocabulary/exports/skos",
+    responses: { 200: "SkosExportResponse" }
+  },
   extendDsr: {
     method: "POST",
     path: "/api/v1/dsr/{id}/extend",
@@ -28343,6 +29466,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/visualization/hypergraph",
     responses: { 200: "HypergraphResponse" }
   },
+  getImport: {
+    method: "GET",
+    path: "/api/v1/vocabulary/imports/{import_id}",
+    responses: { 200: "VocabularyImportResponse" }
+  },
   getInbox: { method: "GET", path: "/api/v1/inbox", responses: { 200: "InboxResponse" } },
   getInferenceJob: {
     method: "GET",
@@ -28399,6 +29527,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/inference/meta-sorts",
     responses: { 200: "MetaSortsResponse" }
   },
+  getMigrationPlan: {
+    method: "GET",
+    path: "/api/v1/vocabulary/migration/plans/{plan_id}",
+    responses: { 200: "MigrationPlanResponse" }
+  },
   getMyTenant: {
     method: "GET",
     path: "/api/v1/tenants/me",
@@ -28414,6 +29547,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/namespaces/{id}/ancestors",
     responses: { 200: "NamespaceListResponse" }
   },
+  getNamespaceAnswerCachePolicy: {
+    method: "GET",
+    path: "/api/v1/namespaces/{id}/answer-cache-policy",
+    responses: { 200: "NamespaceAnswerCachePolicyDto" }
+  },
   getNamespaceByPath: {
     method: "GET",
     path: "/api/v1/namespaces/path/{tenant_id}/{path}",
@@ -28637,6 +29775,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/verification/certificates/{id}",
     responses: { 200: "VerificationCertificateResponse" }
   },
+  getVocabularyCollection: {
+    method: "GET",
+    path: "/api/v1/vocabulary/collections/{collection_id}",
+    responses: { 200: "CollectionDetailResponse" }
+  },
   getWorkflow: { method: "GET", path: "/api/v1/workflows/{id}", responses: { 200: "WorkflowDto" } },
   getWorkflowRun: {
     method: "GET",
@@ -28709,6 +29852,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/ontology/import-foundry",
     responses: { 201: "ImportFoundryResponse" }
   },
+  importItems: {
+    method: "GET",
+    path: "/api/v1/vocabulary/imports/{import_id}/items",
+    responses: { 200: "VocabularyImportItemsResponse" }
+  },
   importKappa: {
     method: "POST",
     path: "/api/v1/injection/kappa",
@@ -29313,6 +30461,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/namespaces/{namespace_id}/visible-terms",
     responses: { 200: "TermListResponse" }
   },
+  listVocabularyCollections: {
+    method: "GET",
+    path: "/api/v1/vocabulary/collections",
+    responses: { 200: "CollectionPageResponse" }
+  },
   listVoices: {
     method: "GET",
     path: "/api/v1/speech/voices",
@@ -30127,6 +31280,31 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/vocabulary/candidates/{candidate_id}/revisions",
     responses: { 201: "CandidateRevisionResponse" }
   },
+  schemeHierarchy: {
+    method: "GET",
+    path: "/api/v1/vocabulary/schemes/{scheme_id}/hierarchy",
+    responses: { 200: "HierarchyResponse" }
+  },
+  schemePaths: {
+    method: "GET",
+    path: "/api/v1/vocabulary/schemes/{scheme_id}/paths",
+    responses: { 200: "HierarchyPathsResponse" }
+  },
+  schemePicklist: {
+    method: "GET",
+    path: "/api/v1/vocabulary/schemes/{scheme_id}/picklist",
+    responses: { 200: "PicklistResponse" }
+  },
+  schemePolicy: {
+    method: "GET",
+    path: "/api/v1/vocabulary/schemes/{scheme_id}/policy",
+    responses: { 200: "TaxonomyPolicyResponse" }
+  },
+  schemeTopConcepts: {
+    method: "GET",
+    path: "/api/v1/vocabulary/schemes/{scheme_id}/top-concepts",
+    responses: { 200: "TopConceptsResponse" }
+  },
   scmCounterfactual: {
     method: "POST",
     path: "/api/v1/causal/counterfactual/scm",
@@ -30267,6 +31445,7 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/constraints/solve",
     responses: { 200: "SolveConstraintResponse" }
   },
+  solveCsp: { method: "POST", path: "/api/v1/csp/solve", responses: { 200: "CspSolveResponse" } },
   solveFlowNetwork: {
     method: "POST",
     path: "/api/v1/flow-networks/{network_id}/solve",
@@ -30294,6 +31473,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/sorts/index/status",
     responses: { 200: "SortIndexStatusResponse" }
   },
+  sparqlQuery: {
+    method: "POST",
+    path: "/api/v1/vocabulary/sparql",
+    responses: { 200: "SparqlResponse" }
+  },
   startExploration: {
     method: "POST",
     path: "/api/v1/analysis/attribute-exploration/start",
@@ -30534,6 +31718,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/cognitive/agents/{agent_id}",
     responses: { 200: "UpdateAgentResponse" }
   },
+  updateNamespaceAnswerCachePolicy: {
+    method: "PUT",
+    path: "/api/v1/namespaces/{id}/answer-cache-policy",
+    responses: { 200: "NamespaceAnswerCachePolicyDto" }
+  },
   updatePlanStats: {
     method: "POST",
     path: "/api/v1/cognitive/agents/plans/stats",
@@ -30635,6 +31824,11 @@ var RESPONSE_OPERATIONS = {
     path: "/api/v1/synthetic/verify-faithfulness",
     responses: { 200: "VerifyFaithfulnessResponse" }
   },
+  verifyFcaExport: {
+    method: "POST",
+    path: "/api/v1/analysis/fca-exports/verify",
+    responses: { 200: "VerifiedFcaImportDto" }
+  },
   verifyIntegrity: {
     method: "POST",
     path: "/api/v1/audit/verify-integrity",
@@ -30996,19 +32190,42 @@ var SortsClient = class {
   /**
    * Propose mixin parents for feature shapes several sorts repeat unchanged.
    *
-   * @param request - Which sorts to analyse (default: all), and the least
-   *   number of sorts a proposal must cover (default and floor: 2).
-   * @returns Candidate parents, most shared declarations first.
-   * @throws {ApiError} If the request fails.
+   * @param request - Which sorts to analyse (default: all), the least number of
+   *   sorts a proposal must cover (default and floor: 2), and optional lower
+   *   budgets in `limits`.
+   * @returns Candidate parents, most shared declarations first, with the input,
+   *   search and presentation coverage of the run.
+   * @throws {ApiError} If the request fails: `400` for an invalid selection or a
+   *   limit above the native ceiling, `403` when a source or ancestor schema is
+   *   not readable, `422` when a declaration cannot be represented losslessly.
    *
    * @remarks
-   * Deterministic and read-only: it groups sorts over identical feature +
-   * constraint declarations. `suggestedName` is a placeholder to rename
-   * before creating the parent.
+   * Never writes. The analysis runs native formal concept analysis over whole
+   * feature declarations and checks each concept. `suggestedName` is a
+   * placeholder to rename before creating the parent.
+   *
+   * Coverage has three independent parts. Read all three before you claim
+   * coverage. `inputComplete` says whether the whole cohort was read within the
+   * limits; when it is `false`, `inputStop` names the stop and no search ran.
+   * `search.complete` says whether the enumeration was exhausted. That
+   * exhaustion concerns the stated tenant and policy cohort only. Presentation
+   * can truncate independently: `presentationStopReason` is set when the list
+   * is shorter than the search result.
+   *
+   * A proposal is a candidate, not an admission. `nativeAdmission` is always
+   * `false`. Neither the report nor its digest `contextSha256` is an admission
+   * seal. To accept a candidate, use the existing governed declaration and
+   * reparenting operations.
+   *
+   * Serialization: the request `limits` keys are sent as snake_case `max_*`.
+   * An absent budget is omitted, never sent as `null`.
    *
    * @example
    * ```typescript
-   * const { proposals } = await client.sorts.factorSorts({ minSorts: 3 });
+   * const report = await client.sorts.factorSorts({ minSorts: 3, limits: { maxProposals: 50 } });
+   * if (report.inputComplete && report.search?.complete && report.presentationStopReason == null) {
+   *   console.log(report.proposals.length);
+   * }
    * ```
    */
   async factorSorts(request = {}, requestOptions) {
@@ -33169,6 +34386,17 @@ function SolutionDtoFromApiToFront(dto) {
   }
   return solution;
 }
+function WhyNotPremiseFromApiToFront(dto) {
+  return {
+    sort: dto.sort,
+    // Premise feature names are user data: kept as written.
+    features: Object.fromEntries(
+      Object.entries(dto.features).filter(
+        (entry) => entry[1] !== void 0
+      )
+    )
+  };
+}
 function WhyNotFromApiToFront(dto) {
   return {
     goalSort: dto.goal_sort,
@@ -33186,14 +34414,9 @@ function WhyNotFromApiToFront(dto) {
     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
-          )
-        )
-      })),
+      blockedBy: r.blocked_by.map(WhyNotPremiseFromApiToFront),
+      // Always sent by the engine; an engine that predates it sends none.
+      undetermined: (r.undetermined ?? []).map(WhyNotPremiseFromApiToFront),
       jointlyUnsatisfied: r.jointly_unsatisfied
     }))
   };
@@ -34888,6 +36111,7 @@ function UnifiableQueryRequestFromFrontToApi(model) {
 }
 function FindBySortRequestFromFrontToApi(model) {
   return {
+    fields: model.fields ?? void 0,
     sort_id: model.sortId ?? void 0,
     sort_name: model.sortName ?? void 0,
     filter: model.filter ?? void 0,
@@ -34986,6 +36210,7 @@ function ToolCallInfoFromApiToFront(dto) {
 function NlQueryRequestFromFrontToApi(model) {
   return {
     query: model.query,
+    fresh: model.fresh,
     mode: model.mode,
     tenant_id: model.tenantId,
     conversation_history: model.conversationHistory ?? void 0,
@@ -35575,6 +36800,7 @@ function CycleOutcomeDtoFromApiToFront(dto) {
     goalsPursued: dto.goals_pursued,
     goalsAchieved: dto.goals_achieved,
     goalsFailed: dto.goals_failed,
+    goalsDeferred: dto.goals_deferred ?? [],
     actionsExecuted: dto.actions_executed,
     newBeliefs: dto.new_beliefs,
     updatedBeliefs: dto.updated_beliefs,
@@ -37894,6 +39120,18 @@ function NamespaceListResponseFromApiToFront(dto) {
     count: dto.count
   };
 }
+function UpdateNamespaceAnswerCachePolicyRequestFromFrontToApi(model) {
+  return { enabled: model.enabled, ttl_seconds: model.ttlSeconds };
+}
+function NamespaceAnswerCachePolicyDtoFromApiToFront(dto) {
+  return {
+    enabled: dto.enabled,
+    ttlSeconds: dto.ttl_seconds,
+    revision: dto.revision,
+    updatedBy: dto.updated_by,
+    updatedAt: dto.updated_at
+  };
+}
 
 // src/resources/namespaces.ts
 var NamespacesClient = class {
@@ -37945,6 +39183,23 @@ var NamespacesClient = class {
     const response = await this.api.getNamespace(namespaceId, toRequestParams(requestOptions));
     return decodeResponse(response, (dto) => NamespaceDtoFromApiToFront(dto.namespace));
   }
+  /** Read durable answer-cache settings. OSFKB checks the native namespace grant. */
+  async getAnswerCachePolicy(namespaceId, requestOptions) {
+    const response = await this.api.getNamespaceAnswerCachePolicy(
+      namespaceId,
+      toRequestParams(requestOptions)
+    );
+    return decodeResponse(response, NamespaceAnswerCachePolicyDtoFromApiToFront);
+  }
+  /** Save settings in OSFKB; policy validation and cache admission stay in the engine. */
+  async updateAnswerCachePolicy(namespaceId, request, requestOptions) {
+    const response = await this.api.updateNamespaceAnswerCachePolicy(
+      namespaceId,
+      UpdateNamespaceAnswerCachePolicyRequestFromFrontToApi(request),
+      toRequestParams(requestOptions)
+    );
+    return decodeResponse(response, NamespaceAnswerCachePolicyDtoFromApiToFront);
+  }
   /**
    * Delete a namespace.
    *
@@ -41146,6 +42401,7 @@ function TranslateRdfResponseFromApiToFront(dto) {
     prefixes: definedRecordOrNullish(dto.prefixes),
     repairedIriCount: dto.repaired_iri_count ?? 0,
     repairedIris: (dto.repaired_iris ?? []).map(IriRepairFromApiToFront),
+    routedToVocabularyImport: dto.routed_to_vocabulary_import ?? 0,
     sortPreviews: (dto.sort_previews ?? []).map(SortPreviewFromApiToFront),
     sorts: dto.sorts,
     termCount: dto.term_count,
@@ -41200,6 +42456,7 @@ function IngestRdfResponseFromApiToFront(dto) {
   return {
     repairedIriCount: dto.repaired_iri_count ?? 0,
     repairedIris: (dto.repaired_iris ?? []).map(IriRepairFromApiToFront),
+    routedToVocabularyImport: dto.routed_to_vocabulary_import ?? 0,
     shapesParsed: dto.shapes_parsed,
     sortNames: dto.sort_names,
     sortsCreated: dto.sorts_created,
@@ -41221,6 +42478,7 @@ function RdfImportReceiptFromApiToFront(dto) {
   return {
     repairedIriCount: dto.repaired_iri_count,
     repairedIris: dto.repaired_iris.map(IriRepairFromApiToFront),
+    routedToVocabularyImport: dto.routed_to_vocabulary_import,
     shapesParsed: dto.shapes_parsed,
     sortsCreated: dto.sorts_created,
     termsCreated: dto.terms_created
@@ -41355,7 +42613,8 @@ function DocumentStatsDtoFromApiToFront(dto) {
     relationsIntegrated: dto.relations_integrated,
     sortNames: dto.sort_names,
     termIds: dto.term_ids,
-    totalTokens: dto.total_tokens
+    totalTokens: dto.total_tokens,
+    fcaDiscovery: dto.fca_discovery ? FcaIngestionReportFromApiToFront(dto.fca_discovery) : void 0
   };
 }
 function SessionStatsResponseFromApiToFront(dto) {
@@ -41737,6 +42996,7 @@ function RdfUploadFromApiToFront(dto) {
     prefixBindings: definedRecord(dto.prefix_bindings ?? {}),
     quadsCommitted: dto.quads_committed,
     batchesCommitted: dto.batches_committed,
+    routedToVocabularyImport: dto.routed_to_vocabulary_import ?? 0,
     resourcesCreated: dto.resources_created,
     sortsCreated: dto.sorts_created,
     error: dto.error,
@@ -49782,6 +51042,28 @@ function SortLicenceResponseFromApiToFront(dto) {
     installedRules: dto.installed_rules
   };
 }
+function FcaExportRequestFromFrontToApi(model) {
+  return {
+    term_ids: model.termIds,
+    max_concepts: model.maxConcepts,
+    min_extent_size: model.minExtentSize,
+    min_intent_size: model.minIntentSize,
+    max_work: model.maxWork,
+    max_visited_concepts: model.maxVisitedConcepts,
+    include_basis: model.includeBasis,
+    basis_max_work: model.basisMaxWork,
+    basis_max_candidates: model.basisMaxCandidates
+  };
+}
+function VerifiedFcaImportFromApiToFront(dto) {
+  return {
+    sources: dto.sources,
+    concepts: dto.concepts,
+    conceptsComplete: dto.concepts_complete,
+    implications: dto.implications ?? null,
+    basisComplete: dto.basis_complete ?? null
+  };
+}
 function ConfluenceConflictDtoFromApiToFront(dto) {
   return {
     kind: dto.kind,
@@ -50097,6 +51379,59 @@ var AnalysisClient = class {
     );
     return decodeResponse(response, SortLicenceResponseFromApiToFront);
   }
+  /**
+   * Export the native FCA of an explicit population.
+   *
+   * @param request - The population and the enumeration (and basis) bounds.
+   * @param requestOptions - Per-call request options.
+   * @returns The replayable export, in its wire form.
+   * @throws {BadRequestError} 400 for an invalid population or budgets beyond
+   *   the supported limits.
+   *
+   * @remarks
+   * The engine computes the concepts of the population's schema-presence
+   * context under the declared bounds and, when asked, its observed
+   * implication basis; the export carries the incidence, the bounds and each
+   * result's completeness so an importer can replay all of it with
+   * {@link verifyFcaExport}.
+   *
+   * @example
+   * ```typescript
+   * const exported = await client.analysis.exportFca({ termIds, includeBasis: true });
+   * const verified = await client.analysis.verifyFcaExport(exported);
+   * console.log(verified.concepts, verified.conceptsComplete);
+   * ```
+   */
+  async exportFca(request, requestOptions) {
+    const response = await this.api.exportFca(
+      FcaExportRequestFromFrontToApi(request),
+      toRequestParams(requestOptions)
+    );
+    return decodeResponse(response, (dto) => dto);
+  }
+  /**
+   * Verify an FCA export for import into the caller's tenant.
+   *
+   * @param fcaExport - The export, exactly as {@link exportFca} returned it.
+   * @param requestOptions - Per-call request options.
+   * @returns What native replay reproduced.
+   * @throws {BadRequestError} 400 when the declared bounds or universe exceed
+   *   the supported limits.
+   * @throws {ApiError} 422 (`status` 422, `errorCode` `fca_export_refused`) when
+   *   a claim, the incidence or the scope does not survive native replay;
+   *   nothing is accepted.
+   *
+   * @remarks
+   * The engine decodes the export's context, recomputes a graded incidence
+   * from its degrees and cut, recomputes its concepts and basis under its
+   * declared bounds, and requires each claim, completeness included, to equal
+   * its recomputation; every object must name a source term of the caller's
+   * tenant.
+   */
+  async verifyFcaExport(fcaExport, requestOptions) {
+    const response = await this.api.verifyFcaExport(fcaExport, toRequestParams(requestOptions));
+    return decodeResponse(response, VerifiedFcaImportFromApiToFront);
+  }
   /**
    * Invite a gateway human user to an exploration session.
    *
@@ -52951,7 +54286,23 @@ var VOCABULARY_REFUSAL_CODES = members({
   vocabulary_outcome_unconfirmed: true,
   no_committed_outcome: true,
   governed_sort_write_refused: true,
-  read_budget_exceeded: true
+  read_budget_exceeded: true,
+  cursor_mismatch: true,
+  format_unsupported: true,
+  source_too_large: true,
+  source_file_not_found: true,
+  import_incomplete: true,
+  import_too_large: true,
+  import_already_committed: true,
+  import_baseline_stale: true,
+  reconciliation_undecided: true,
+  invalid_decision: true,
+  migration_plan_stale: true,
+  invalid_disposition: true,
+  sparql_unsupported: true,
+  vocabulary_sparql_unavailable: true,
+  sparql_deadline: true,
+  export_unrepresentable: true
 });
 var VOCABULARY_FINDING_CODES = members({
   declaration_violation: true,
@@ -52972,7 +54323,24 @@ var VOCABULARY_FINDING_CODES = members({
   evidence_provenance_unknown: true,
   stale_baseline: true,
   plugin_context_changed: true,
-  language_unknown: true
+  language_unknown: true,
+  hierarchy_self_link: true,
+  hierarchy_cycle: true,
+  hierarchy_depth_exceeded: true,
+  partitive_interpretation_unresolved: true,
+  relation_outside_scheme: true,
+  related_also_hierarchical: true,
+  top_concept_has_broader: true,
+  missing_top_concept: true,
+  unplaced_concept: true,
+  mapping_conflict: true,
+  mapping_target_unavailable: true,
+  notation_duplicate: true,
+  collection_member_dangling: true,
+  collection_cycle: true,
+  collection_position_duplicate: true,
+  collection_position_missing: true,
+  xl_label_without_label_use: true
 });
 var VOCABULARY_FINDING_SEVERITIES = members({
   blocking: true,
@@ -53020,7 +54388,11 @@ var VOCABULARY_OPERATIONS = members({
   reject: true,
   withdraw: true,
   release: true,
-  activate: true
+  activate: true,
+  create_import: true,
+  commit_import: true,
+  create_migration_plan: true,
+  apply_migration_plan: true
 });
 
 // src/utils/vocabulary-refusal.ts
@@ -53166,7 +54538,9 @@ function readRefusal(body) {
     findingIds: optionalStrings(wire.finding_ids, "finding_ids"),
     conflicts: optionalList(wire.conflicts, "conflicts", readConflict),
     recordErrors: optionalList(wire.record_errors, "record_errors", readRecordError),
-    missingRelations: optionalStrings(wire.missing_relations, "missing_relations")
+    missingRelations: optionalStrings(wire.missing_relations, "missing_relations"),
+    undecidedSourceKeys: optionalStrings(wire.undecided_source_keys, "undecided_source_keys"),
+    changedSorts: optionalStrings(wire.changed_sorts, "changed_sorts")
   };
   if (!isAbsent(wire.current)) out.current = readCurrent(wire.current, "current");
   if (!isAbsent(wire.authority)) out.authority = readAuthority(wire.authority, "authority");
@@ -61510,7 +62884,11 @@ function ImportOwlResponseFromApiToFront(dto) {
   return {
     reifiedSortsCreated: dto.reified_sorts_created,
     relationsDiscovered: dto.relations_discovered,
-    sortsCreated: dto.sorts_created
+    sortsCreated: dto.sorts_created,
+    sortsRefused: (dto.sorts_refused ?? []).map((sort) => ({
+      name: sort.name,
+      reason: sort.reason
+    }))
   };
 }
 function ExecuteTranspiledRequestFromFrontToApi(model) {
@@ -69129,6 +70507,99 @@ function AboutnessInputFromFrontToApi(record) {
   }
   return out;
 }
+function ConceptRelationInputFromFrontToApi(record) {
+  const out = {
+    scheme: VocabularyRecordRefFromFrontToApi(record.scheme),
+    subject: VocabularyRecordRefFromFrontToApi(record.subject),
+    object: VocabularyRecordRefFromFrontToApi(record.object),
+    relation: record.relation,
+    status: record.status
+  };
+  if (record.hierarchyKind !== void 0) out.hierarchy_kind = record.hierarchyKind;
+  if (record.evidence !== void 0) {
+    out.evidence = VocabularyRecordRefFromFrontToApi(record.evidence);
+  }
+  return out;
+}
+function TaxonomyPolicyInputFromFrontToApi(record) {
+  const out = {
+    scheme: VocabularyRecordRefFromFrontToApi(record.scheme),
+    acyclic: record.acyclic,
+    require_placement: record.requirePlacement,
+    top_concepts: record.topConcepts
+  };
+  if (record.maxDepth !== void 0) out.max_depth = record.maxDepth;
+  if (record.partitiveTransitive !== void 0) {
+    out.partitive_transitive = record.partitiveTransitive;
+  }
+  return out;
+}
+function ExternalConceptInputFromFrontToApi(record) {
+  const out = {
+    authority: record.authority,
+    dataset_version: record.datasetVersion,
+    iri: record.iri,
+    resolution: record.resolution
+  };
+  if (record.recordId !== void 0) out.record_id = record.recordId;
+  if (record.clientRef !== void 0) out.client_ref = record.clientRef;
+  if (record.labelText !== void 0) out.label_text = record.labelText;
+  if (record.labelLanguage !== void 0) out.label_language = record.labelLanguage;
+  if (record.evidence !== void 0) {
+    out.evidence = VocabularyRecordRefFromFrontToApi(record.evidence);
+  }
+  return out;
+}
+function MappingTargetFromFrontToApi(target) {
+  return "concept" in target ? { concept: VocabularyRecordRefFromFrontToApi(target.concept) } : { external: VocabularyRecordRefFromFrontToApi(target.external) };
+}
+function ConceptMappingInputFromFrontToApi(record) {
+  const out = {
+    subject: VocabularyRecordRefFromFrontToApi(record.subject),
+    target: MappingTargetFromFrontToApi(record.target),
+    mapping_kind: record.mappingKind,
+    status: record.status
+  };
+  if (record.evidence !== void 0) {
+    out.evidence = VocabularyRecordRefFromFrontToApi(record.evidence);
+  }
+  return out;
+}
+function DocumentationInputFromFrontToApi(record) {
+  const out = {
+    subject: VocabularyRecordRefFromFrontToApi(record.subject),
+    note_kind: record.noteKind
+  };
+  if (record.recordId !== void 0) out.record_id = record.recordId;
+  if (record.clientRef !== void 0) out.client_ref = record.clientRef;
+  if (record.text !== void 0) out.text = record.text;
+  if (record.resourceLocator !== void 0) out.resource_locator = record.resourceLocator;
+  if (record.language !== void 0) out.language = record.language;
+  if (record.evidence !== void 0) {
+    out.evidence = VocabularyRecordRefFromFrontToApi(record.evidence);
+  }
+  return out;
+}
+function CollectionInputFromFrontToApi(record) {
+  const out = {
+    scheme: VocabularyRecordRefFromFrontToApi(record.scheme),
+    ordered: record.ordered,
+    status: record.status
+  };
+  if (record.recordId !== void 0) out.record_id = record.recordId;
+  if (record.clientRef !== void 0) out.client_ref = record.clientRef;
+  return out;
+}
+function CollectionMemberInputFromFrontToApi(record) {
+  const out = {
+    collection: VocabularyRecordRefFromFrontToApi(record.collection),
+    member: VocabularyRecordRefFromFrontToApi(record.member)
+  };
+  if (record.recordId !== void 0) out.record_id = record.recordId;
+  if (record.clientRef !== void 0) out.client_ref = record.clientRef;
+  if (record.position !== void 0) out.position = record.position;
+  return out;
+}
 function VocabularyRecordInputFromFrontToApi(record) {
   switch (record.kind) {
     case "scheme":
@@ -69172,6 +70643,55 @@ function VocabularyRecordInputFromFrontToApi(record) {
       return { kind: "identity_decision", ...IdentityDecisionInputFromFrontToApi(record) };
     case "aboutness":
       return { kind: "aboutness", ...AboutnessInputFromFrontToApi(record) };
+    case "concept_relation":
+      return { kind: "concept_relation", ...ConceptRelationInputFromFrontToApi(record) };
+    case "taxonomy_policy":
+      return { kind: "taxonomy_policy", ...TaxonomyPolicyInputFromFrontToApi(record) };
+    case "external_concept":
+      return { kind: "external_concept", ...ExternalConceptInputFromFrontToApi(record) };
+    case "concept_mapping":
+      return { kind: "concept_mapping", ...ConceptMappingInputFromFrontToApi(record) };
+    case "documentation":
+      return { kind: "documentation", ...DocumentationInputFromFrontToApi(record) };
+    case "notation": {
+      const out = {
+        kind: "notation",
+        concept: VocabularyRecordRefFromFrontToApi(record.concept),
+        scheme: VocabularyRecordRefFromFrontToApi(record.scheme),
+        value: record.value
+      };
+      if (record.datatype !== void 0) out.datatype = record.datatype;
+      return out;
+    }
+    case "xl_label":
+      return {
+        kind: "xl_label",
+        concept: VocabularyRecordRefFromFrontToApi(record.concept),
+        scheme: VocabularyRecordRefFromFrontToApi(record.scheme),
+        resource_key: record.resourceKey,
+        text: record.text,
+        language: record.language,
+        role: record.role
+      };
+    case "label_relation":
+      return {
+        kind: "label_relation",
+        subject: VocabularyRecordRefFromFrontToApi(record.subject),
+        object: VocabularyRecordRefFromFrontToApi(record.object),
+        relation: record.relation
+      };
+    case "collection":
+      return { kind: "collection", ...CollectionInputFromFrontToApi(record) };
+    case "collection_label":
+      return {
+        kind: "collection_label",
+        collection: VocabularyRecordRefFromFrontToApi(record.collection),
+        text: record.text,
+        language: record.language,
+        role: record.role
+      };
+    case "collection_member":
+      return { kind: "collection_member", ...CollectionMemberInputFromFrontToApi(record) };
   }
 }
 function VocabularyRecordOperationFromFrontToApi(operation) {
@@ -69279,6 +70799,79 @@ function ActivateVocabularyReleaseRequestFromFrontToApi(request) {
   if (request.rationale !== void 0) out.rationale = request.rationale;
   return out;
 }
+function VocabularyImportTargetSchemeFromFrontToApi(target) {
+  return "existing" in target ? { existing: { scheme_id: target.existing.schemeId } } : { new: { scheme: SchemeInputFromFrontToApi(target.new.scheme) } };
+}
+function ExternalAuthorityFromFrontToApi(authority) {
+  return {
+    iri_prefix: authority.iriPrefix,
+    authority: authority.authority,
+    dataset_version: authority.datasetVersion
+  };
+}
+function CreateVocabularyImportRequestFromFrontToApi(request) {
+  const out = {
+    source_file_id: request.sourceFileId,
+    format: request.format,
+    dataset: request.dataset,
+    target_scheme: VocabularyImportTargetSchemeFromFrontToApi(request.targetScheme)
+  };
+  if (request.schemeMap !== void 0) out.scheme_map = request.schemeMap;
+  if (request.defaultLanguage !== void 0) out.default_language = request.defaultLanguage;
+  if (request.externalAuthorities !== void 0) {
+    out.external_authorities = request.externalAuthorities.map(ExternalAuthorityFromFrontToApi);
+  }
+  if (request.attribution !== void 0) out.attribution = request.attribution;
+  if (request.license !== void 0) out.license = request.license;
+  return out;
+}
+function ResourceDecisionFromFrontToApi(decision) {
+  const out = {
+    source_key: decision.sourceKey,
+    decision: decision.decision
+  };
+  if (decision.conceptId !== void 0) out.concept_id = decision.conceptId;
+  if (decision.rationale !== void 0) out.rationale = decision.rationale;
+  return out;
+}
+function CommitVocabularyImportRequestFromFrontToApi(request) {
+  const out = { change_reason: request.changeReason };
+  if (request.title !== void 0) out.title = request.title;
+  if (request.candidateId !== void 0) out.candidate_id = request.candidateId;
+  if (request.decisions !== void 0) {
+    out.decisions = request.decisions.map(ResourceDecisionFromFrontToApi);
+  }
+  return out;
+}
+function PlannedDispositionFromFrontToApi(disposition) {
+  return {
+    sort_id: disposition.sortId,
+    disposition: disposition.disposition,
+    rationale: disposition.rationale
+  };
+}
+function CreateVocabularyMigrationPlanRequestFromFrontToApi(request) {
+  return { dispositions: request.dispositions.map(PlannedDispositionFromFrontToApi) };
+}
+function ApplyVocabularyMigrationPlanRequestFromFrontToApi(request) {
+  const out = {
+    title: request.title,
+    change_reason: request.changeReason,
+    scheme: VocabularyImportTargetSchemeFromFrontToApi(request.scheme)
+  };
+  if (request.defaultLanguage !== void 0) out.default_language = request.defaultLanguage;
+  return out;
+}
+function VocabularySparqlRequestFromFrontToApi(request) {
+  const out = { query: request.query, scheme_id: request.schemeId };
+  if (request.view !== void 0) {
+    out.view = request.view.view;
+    if (request.view.view === "release") out.release_id = request.view.releaseId;
+    if (request.view.view === "candidate") out.revision_id = request.view.revisionId;
+  }
+  if (request.maxResults !== void 0) out.max_results = request.maxResults;
+  return out;
+}
 function VocabularySchemeRecordFromApiToFront(dto) {
   const out = {
     recordId: dto.record_id,
@@ -69434,6 +71027,186 @@ function VocabularyAboutnessRecordFromApiToFront(dto) {
   if (present(dto.evidence)) out.evidence = dto.evidence;
   return out;
 }
+function VocabularyConceptRelationRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    scheme: dto.scheme,
+    subject: dto.subject,
+    object: dto.object,
+    relation: dto.relation,
+    status: dto.status
+  };
+  if (present(dto.hierarchy_kind)) out.hierarchyKind = dto.hierarchy_kind;
+  if (present(dto.evidence)) out.evidence = dto.evidence;
+  return out;
+}
+function VocabularyTaxonomyPolicyRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    scheme: dto.scheme,
+    policy: dto.policy,
+    acyclic: dto.acyclic,
+    requirePlacement: dto.require_placement,
+    topConcepts: dto.top_concepts
+  };
+  if (present(dto.max_depth)) out.maxDepth = dto.max_depth;
+  if (present(dto.partitive_transitive)) out.partitiveTransitive = dto.partitive_transitive;
+  return out;
+}
+function VocabularyExternalConceptRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    authority: dto.authority,
+    datasetVersion: dto.dataset_version,
+    iri: dto.iri,
+    resolution: dto.resolution
+  };
+  if (present(dto.label_text)) out.labelText = dto.label_text;
+  if (present(dto.label_language)) out.labelLanguage = dto.label_language;
+  if (present(dto.evidence)) out.evidence = dto.evidence;
+  return out;
+}
+function VocabularyConceptMappingRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    subject: dto.subject,
+    mappingKind: dto.mapping_kind,
+    status: dto.status
+  };
+  if (present(dto.target_concept)) out.targetConcept = dto.target_concept;
+  if (present(dto.target_external)) out.targetExternal = dto.target_external;
+  if (present(dto.evidence)) out.evidence = dto.evidence;
+  return out;
+}
+function VocabularyDocumentationRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    noteKind: dto.note_kind
+  };
+  if (present(dto.concept)) out.concept = dto.concept;
+  if (present(dto.scheme)) out.scheme = dto.scheme;
+  if (present(dto.collection)) out.collection = dto.collection;
+  if (present(dto.text)) out.text = dto.text;
+  if (present(dto.resource_locator)) out.resourceLocator = dto.resource_locator;
+  if (present(dto.language)) out.language = dto.language;
+  if (present(dto.language_as_submitted)) out.languageAsSubmitted = dto.language_as_submitted;
+  if (present(dto.evidence)) out.evidence = dto.evidence;
+  return out;
+}
+function VocabularyNotationRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    concept: dto.concept,
+    scheme: dto.scheme,
+    value: dto.value
+  };
+  if (present(dto.datatype)) out.datatype = dto.datatype;
+  return out;
+}
+function VocabularyXlLabelRecordFromApiToFront(dto) {
+  return {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    concept: dto.concept,
+    scheme: dto.scheme,
+    resourceKey: dto.resource_key,
+    label: dto.label,
+    role: dto.role
+  };
+}
+function VocabularyLabelRelationRecordFromApiToFront(dto) {
+  return {
+    recordId: dto.record_id,
+    subject: dto.subject,
+    object: dto.object,
+    relation: dto.relation
+  };
+}
+function VocabularyCollectionRecordFromApiToFront(dto) {
+  return {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    scheme: dto.scheme,
+    ordered: dto.ordered,
+    status: dto.status
+  };
+}
+function VocabularyCollectionLabelRecordFromApiToFront(dto) {
+  return {
+    recordId: dto.record_id,
+    collection: dto.collection,
+    label: dto.label,
+    role: dto.role
+  };
+}
+function VocabularyCollectionMemberRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    collection: dto.collection
+  };
+  if (present(dto.member_concept)) out.memberConcept = dto.member_concept;
+  if (present(dto.member_collection)) out.memberCollection = dto.member_collection;
+  if (present(dto.position)) out.position = dto.position;
+  return out;
+}
+function VocabularySourceArtifactRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    sha256: dto.sha256,
+    byteSize: dto.byte_size,
+    format: dto.format,
+    dataset: dto.dataset,
+    retainedLocator: dto.retained_locator
+  };
+  if (present(dto.file_name)) out.fileName = dto.file_name;
+  if (present(dto.media_type)) out.mediaType = dto.media_type;
+  if (present(dto.attribution)) out.attribution = dto.attribution;
+  if (present(dto.license)) out.license = dto.license;
+  if (present(dto.retrieval_context)) out.retrievalContext = dto.retrieval_context;
+  return out;
+}
+function VocabularySourceAssociationRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    artifact: dto.artifact,
+    sourceKey: dto.source_key
+  };
+  if (present(dto.concept)) out.concept = dto.concept;
+  if (present(dto.collection)) out.collection = dto.collection;
+  if (present(dto.external_concept)) out.externalConcept = dto.external_concept;
+  return out;
+}
+function VocabularyMigrationDecisionRecordFromApiToFront(dto) {
+  const out = {
+    recordId: dto.record_id,
+    revision: dto.revision,
+    changeReason: dto.change_reason,
+    plan: dto.plan,
+    legacySort: dto.legacy_sort,
+    legacySortName: dto.legacy_sort_name,
+    fingerprint: dto.fingerprint,
+    disposition: dto.disposition,
+    rationale: dto.rationale
+  };
+  if (present(dto.concept)) out.concept = dto.concept;
+  return out;
+}
 function VocabularyRecordViewFromApiToFront(dto) {
   switch (dto.kind) {
     case "scheme":
@@ -69468,6 +71241,40 @@ function VocabularyRecordViewFromApiToFront(dto) {
       };
     case "aboutness":
       return { kind: "aboutness", ...VocabularyAboutnessRecordFromApiToFront(dto) };
+    case "concept_relation":
+      return { kind: "concept_relation", ...VocabularyConceptRelationRecordFromApiToFront(dto) };
+    case "taxonomy_policy":
+      return { kind: "taxonomy_policy", ...VocabularyTaxonomyPolicyRecordFromApiToFront(dto) };
+    case "external_concept":
+      return { kind: "external_concept", ...VocabularyExternalConceptRecordFromApiToFront(dto) };
+    case "concept_mapping":
+      return { kind: "concept_mapping", ...VocabularyConceptMappingRecordFromApiToFront(dto) };
+    case "documentation":
+      return { kind: "documentation", ...VocabularyDocumentationRecordFromApiToFront(dto) };
+    case "notation":
+      return { kind: "notation", ...VocabularyNotationRecordFromApiToFront(dto) };
+    case "xl_label":
+      return { kind: "xl_label", ...VocabularyXlLabelRecordFromApiToFront(dto) };
+    case "label_relation":
+      return { kind: "label_relation", ...VocabularyLabelRelationRecordFromApiToFront(dto) };
+    case "collection":
+      return { kind: "collection", ...VocabularyCollectionRecordFromApiToFront(dto) };
+    case "collection_label":
+      return { kind: "collection_label", ...VocabularyCollectionLabelRecordFromApiToFront(dto) };
+    case "collection_member":
+      return { kind: "collection_member", ...VocabularyCollectionMemberRecordFromApiToFront(dto) };
+    case "source_artifact":
+      return { kind: "source_artifact", ...VocabularySourceArtifactRecordFromApiToFront(dto) };
+    case "source_association":
+      return {
+        kind: "source_association",
+        ...VocabularySourceAssociationRecordFromApiToFront(dto)
+      };
+    case "migration_decision":
+      return {
+        kind: "migration_decision",
+        ...VocabularyMigrationDecisionRecordFromApiToFront(dto)
+      };
   }
 }
 function FindingContextFromApiToFront(dto) {
@@ -69696,7 +71503,16 @@ function ConceptViewFromApiToFront(dto) {
     authorityReferences: dto.authority_references.map(
       VocabularyAuthorityReferenceRecordFromApiToFront
     ),
-    aboutness: dto.aboutness.map(VocabularyAboutnessRecordFromApiToFront)
+    aboutness: dto.aboutness.map(VocabularyAboutnessRecordFromApiToFront),
+    relations: dto.relations.map(VocabularyConceptRelationRecordFromApiToFront),
+    mappings: dto.mappings.map(VocabularyConceptMappingRecordFromApiToFront),
+    documentation: dto.documentation.map(VocabularyDocumentationRecordFromApiToFront),
+    notations: dto.notations.map(VocabularyNotationRecordFromApiToFront),
+    xlLabels: dto.xl_labels.map(VocabularyXlLabelRecordFromApiToFront),
+    collections: dto.collections,
+    sourceAssociations: dto.source_associations.map(
+      VocabularySourceAssociationRecordFromApiToFront
+    )
   };
   if (present(dto.display_label)) {
     out.displayLabel = VocabularyDisplayLabelFromApiToFront(dto.display_label);
@@ -70004,6 +71820,12 @@ function isReleaseBody(value) {
 function isActivationBody(value) {
   return componentFault(value, "ActivationResponse", "body") === void 0;
 }
+function isImportBody(value) {
+  return componentFault(value, "VocabularyImportResponse", "body") === void 0;
+}
+function isMigrationPlanBody(value) {
+  return componentFault(value, "MigrationPlanResponse", "body") === void 0;
+}
 var COMMITTED_COMPONENT = {
   create_candidate: "CandidateRevisionResponse",
   save_revision: "CandidateRevisionResponse",
@@ -70015,13 +71837,19 @@ var COMMITTED_COMPONENT = {
   reject: "DecisionResponse",
   withdraw: "DecisionResponse",
   release: "ReleaseResponse",
-  activate: "ActivationResponse"
+  activate: "ActivationResponse",
+  create_import: "VocabularyImportResponse",
+  commit_import: "CandidateRevisionResponse",
+  create_migration_plan: "MigrationPlanResponse",
+  apply_migration_plan: "CandidateRevisionResponse"
 };
 function CommittedResultFromApiToFront(operation, body) {
   switch (operation) {
     case "create_candidate":
     case "save_revision":
     case "rebase":
+    case "commit_import":
+    case "apply_migration_plan":
       if (isCandidateRevisionBody(body)) {
         return { operation, body: VocabularyCandidateRevisionFromApiToFront(body) };
       }
@@ -70050,6 +71878,16 @@ function CommittedResultFromApiToFront(operation, body) {
         return { operation, body: VocabularyActivationResultFromApiToFront(body) };
       }
       break;
+    case "create_import":
+      if (isImportBody(body)) {
+        return { operation, body: VocabularyImportFromApiToFront(body) };
+      }
+      break;
+    case "create_migration_plan":
+      if (isMigrationPlanBody(body)) {
+        return { operation, body: VocabularyMigrationPlanFromApiToFront(body) };
+      }
+      break;
   }
   throw new TypeError(
     componentFault(body, COMMITTED_COMPONENT[operation], "body") ?? `body is not a ${COMMITTED_COMPONENT[operation]}`
@@ -70132,6 +71970,567 @@ function VocabularyMigrationPreviewFromApiToFront(dto) {
   if (present(dto.next_cursor)) out.nextCursor = dto.next_cursor;
   return out;
 }
+function HierarchyNodeFromApiToFront(dto) {
+  const out = {
+    conceptId: dto.concept_id,
+    depth: dto.depth,
+    via: dto.via
+  };
+  if (present(dto.display_label)) {
+    out.displayLabel = VocabularyDisplayLabelFromApiToFront(dto.display_label);
+  }
+  return out;
+}
+function HierarchyEdgeFromApiToFront(dto) {
+  const out = {
+    relationId: dto.relation_id,
+    subject: dto.subject,
+    object: dto.object,
+    status: dto.status
+  };
+  if (present(dto.hierarchy_kind)) out.hierarchyKind = dto.hierarchy_kind;
+  return out;
+}
+function VocabularyHierarchyFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    schemeId: dto.scheme_id,
+    direction: dto.direction,
+    transitive: dto.transitive,
+    nodes: dto.nodes.map(HierarchyNodeFromApiToFront),
+    edges: dto.edges.map(HierarchyEdgeFromApiToFront),
+    complete: dto.complete
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  if (present(dto.root)) out.root = dto.root;
+  if (present(dto.stop_reason)) out.stopReason = dto.stop_reason;
+  return out;
+}
+function VocabularyHierarchyPathsFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    schemeId: dto.scheme_id,
+    from: dto.from,
+    to: dto.to,
+    paths: dto.paths,
+    complete: dto.complete
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  if (present(dto.stop_reason)) out.stopReason = dto.stop_reason;
+  return out;
+}
+function VocabularyTopConceptsFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    schemeId: dto.scheme_id,
+    concepts: dto.concepts.map(ConceptSummaryFromApiToFront)
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  return out;
+}
+function VocabularyTaxonomyPolicyFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    schemeId: dto.scheme_id,
+    declared: dto.declared,
+    policy: dto.policy,
+    acyclic: dto.acyclic,
+    requirePlacement: dto.require_placement,
+    topConcepts: dto.top_concepts
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  if (present(dto.record_id)) out.recordId = dto.record_id;
+  if (present(dto.revision)) out.revision = dto.revision;
+  if (present(dto.change_reason)) out.changeReason = dto.change_reason;
+  if (present(dto.max_depth)) out.maxDepth = dto.max_depth;
+  if (present(dto.partitive_transitive)) out.partitiveTransitive = dto.partitive_transitive;
+  return out;
+}
+function ConceptRelationEntryFromApiToFront(dto) {
+  const out = {
+    relationId: dto.relation_id,
+    relation: dto.relation,
+    conceptId: dto.concept_id,
+    status: dto.status
+  };
+  if (present(dto.display_label)) {
+    out.displayLabel = VocabularyDisplayLabelFromApiToFront(dto.display_label);
+  }
+  if (present(dto.hierarchy_kind)) out.hierarchyKind = dto.hierarchy_kind;
+  if (present(dto.evidence)) out.evidence = dto.evidence;
+  return out;
+}
+function VocabularyConceptRelationsFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    conceptId: dto.concept_id,
+    schemeId: dto.scheme_id,
+    relation: dto.relation,
+    relations: dto.relations.map(ConceptRelationEntryFromApiToFront)
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  return out;
+}
+function CollectionLabelViewFromApiToFront(dto) {
+  const out = {
+    collectionLabelId: dto.collection_label_id,
+    labelId: dto.label_id,
+    role: dto.role
+  };
+  if (present(dto.text)) out.text = dto.text;
+  if (present(dto.language)) out.language = dto.language;
+  return out;
+}
+function CollectionSummaryFromApiToFront(dto) {
+  return {
+    collection: VocabularyCollectionRecordFromApiToFront(dto.collection),
+    labels: dto.labels.map(CollectionLabelViewFromApiToFront),
+    memberCount: dto.member_count
+  };
+}
+function VocabularyCollectionPageFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    schemeId: dto.scheme_id,
+    items: dto.items.map(CollectionSummaryFromApiToFront),
+    complete: dto.complete
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  if (present(dto.next_cursor)) out.nextCursor = dto.next_cursor;
+  return out;
+}
+function CollectionMemberViewFromApiToFront(dto) {
+  const out = { occurrenceId: dto.occurrence_id };
+  if (present(dto.member_concept)) out.memberConcept = dto.member_concept;
+  if (present(dto.member_collection)) out.memberCollection = dto.member_collection;
+  if (present(dto.position)) out.position = dto.position;
+  if (present(dto.display_label)) {
+    out.displayLabel = VocabularyDisplayLabelFromApiToFront(dto.display_label);
+  }
+  return out;
+}
+function VocabularyCollectionDetailFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    collection: VocabularyCollectionRecordFromApiToFront(dto.collection),
+    labels: dto.labels.map(CollectionLabelViewFromApiToFront),
+    members: dto.members.map(CollectionMemberViewFromApiToFront),
+    nestedCollections: dto.nested_collections
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  return out;
+}
+function PicklistEntryFromApiToFront(dto) {
+  const out = {
+    conceptId: dto.concept_id,
+    depth: dto.depth,
+    otherParentRelationIds: dto.other_parent_relation_ids
+  };
+  if (present(dto.display_label)) {
+    out.displayLabel = VocabularyDisplayLabelFromApiToFront(dto.display_label);
+  }
+  if (present(dto.parent_relation_id)) out.parentRelationId = dto.parent_relation_id;
+  return out;
+}
+function VocabularyPicklistFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    schemeId: dto.scheme_id,
+    rootsFrom: dto.roots_from,
+    roots: dto.roots,
+    entries: dto.entries.map(PicklistEntryFromApiToFront),
+    complete: dto.complete
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  if (present(dto.root)) out.root = dto.root;
+  if (present(dto.next_cursor)) out.nextCursor = dto.next_cursor;
+  if (present(dto.stop_reason)) out.stopReason = dto.stop_reason;
+  return out;
+}
+function ExpandedConceptFromApiToFront(dto) {
+  const out = { conceptId: dto.concept_id, support: dto.support };
+  if (present(dto.depth)) out.depth = dto.depth;
+  if (present(dto.display_label)) {
+    out.displayLabel = VocabularyDisplayLabelFromApiToFront(dto.display_label);
+  }
+  return out;
+}
+function VocabularyExpansionFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    conceptId: dto.concept_id,
+    schemeId: dto.scheme_id,
+    direction: dto.direction,
+    transitive: dto.transitive,
+    concepts: dto.concepts.map(ExpandedConceptFromApiToFront),
+    externalConcepts: dto.external_concepts.map(
+      (external) => ({
+        externalConceptId: external.external_concept_id,
+        iri: external.iri,
+        support: external.support
+      })
+    ),
+    withheldRelationIds: dto.withheld_relation_ids,
+    complete: dto.complete
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  if (present(dto.stop_reason)) out.stopReason = dto.stop_reason;
+  return out;
+}
+function ReconciliationProposalFromApiToFront(dto) {
+  switch (dto.proposal) {
+    case "exact_source_match":
+      return { proposal: "exact_source_match", target: dto.target };
+    case "ambiguous":
+      return { proposal: "ambiguous", candidates: dto.candidates };
+    case "new":
+      return { proposal: "new" };
+  }
+}
+function ReconciliationEntryFromApiToFront(dto) {
+  return {
+    sourceKey: dto.source_key,
+    kind: dto.kind,
+    proposal: ReconciliationProposalFromApiToFront(dto.proposal)
+  };
+}
+function VocabularyImportFromApiToFront(dto) {
+  const out = {
+    importId: dto.import_id,
+    artifact: {
+      sourceFileId: dto.artifact.source_file_id,
+      sha256: dto.artifact.sha256,
+      byteSize: dto.artifact.byte_size,
+      format: dto.artifact.format
+    },
+    dataset: dto.dataset,
+    complete: dto.complete,
+    counts: dataMap(dto.counts),
+    proposedRecordCounts: dataMap(dto.proposed_record_counts),
+    reconciliation: dto.reconciliation.map(ReconciliationEntryFromApiToFront),
+    createdBy: dto.created_by,
+    createdAt: dto.created_at,
+    replayed: dto.replayed
+  };
+  if (present(dto.stop_reason)) out.stopReason = dto.stop_reason;
+  if (present(dto.baseline_release_id)) out.baselineReleaseId = dto.baseline_release_id;
+  if (present(dto.committed_revision_id)) out.committedRevisionId = dto.committed_revision_id;
+  if (present(dto.committed_at)) out.committedAt = dto.committed_at;
+  return out;
+}
+function externalVariant(value, path) {
+  const wire = wireObject(value, path);
+  const entries = Object.entries(wire);
+  const first = entries[0];
+  if (entries.length !== 1 || first === void 0) {
+    throw new TypeError(`${path} is not a single-variant object`);
+  }
+  return first;
+}
+function ImportCoordinatesFromWire(value, path) {
+  const [variant, body] = externalVariant(value, path);
+  const at = `${path}.${variant}`;
+  switch (variant) {
+    case "triple": {
+      const wire = wireObject(body, at);
+      return { triple: { index: wireNumber(wire.index, `${at}.index`) } };
+    }
+    case "text": {
+      const wire = wireObject(body, at);
+      return {
+        text: {
+          line: wireNumber(wire.line, `${at}.line`),
+          column: wireNumber(wire.column, `${at}.column`),
+          offset: wireNumber(wire.offset, `${at}.offset`)
+        }
+      };
+    }
+    case "row": {
+      const wire = wireObject(body, at);
+      const row = { row: wireNumber(wire.row, `${at}.row`) };
+      if (present(wire.sheet)) row.sheet = wireString(wire.sheet, `${at}.sheet`);
+      return { row };
+    }
+    case "cell": {
+      const wire = wireObject(body, at);
+      return {
+        cell: {
+          sheet: wireString(wire.sheet, `${at}.sheet`),
+          cell: wireString(wire.cell, `${at}.cell`)
+        }
+      };
+    }
+    case "part": {
+      const wire = wireObject(body, at);
+      return { part: { name: wireString(wire.name, `${at}.name`) } };
+    }
+    case "legacy_sort": {
+      const wire = wireObject(body, at);
+      return { legacySort: { sortId: wireString(wire.sort_id, `${at}.sort_id`) } };
+    }
+    case "json_pointer": {
+      const wire = wireObject(body, at);
+      return { jsonPointer: { pointer: wireString(wire.pointer, `${at}.pointer`) } };
+    }
+  }
+  throw new TypeError(`${path} has the unknown variant ${variant}`);
+}
+function SourceTermFromWire(value, path) {
+  const [variant, body] = externalVariant(value, path);
+  const at = `${path}.${variant}`;
+  switch (variant) {
+    case "iri":
+      return { iri: wireString(body, at) };
+    case "blank":
+      return { blank: wireString(body, at) };
+    case "literal": {
+      const wire = wireObject(body, at);
+      const literal = {
+        value: wireString(wire.value, `${at}.value`),
+        datatype: wireString(wire.datatype, `${at}.datatype`)
+      };
+      if (present(wire.language)) literal.language = wireString(wire.language, `${at}.language`);
+      return { literal };
+    }
+  }
+  throw new TypeError(`${path} has the unknown variant ${variant}`);
+}
+var SOURCE_ITEM_KINDS = ["statement", "row", "record", "rejected"];
+function SourceItemFromWire(value, path) {
+  const wire = wireObject(value, path);
+  const coordinates = ImportCoordinatesFromWire(wire.coordinates, `${path}.coordinates`);
+  const kind = wireLiteral(wire.item, SOURCE_ITEM_KINDS, `${path}.item`);
+  switch (kind) {
+    case "statement":
+      return {
+        item: "statement",
+        coordinates,
+        subject: SourceTermFromWire(wire.subject, `${path}.subject`),
+        predicate: wireString(wire.predicate, `${path}.predicate`),
+        object: SourceTermFromWire(wire.object, `${path}.object`)
+      };
+    case "row": {
+      const cells = {};
+      for (const [column, text] of Object.entries(wireObject(wire.cells, `${path}.cells`))) {
+        cells[column] = wireString(text, `${path}.cells.${column}`);
+      }
+      return {
+        item: "row",
+        coordinates,
+        cells,
+        formulas: wireStringArray(wire.formulas, `${path}.formulas`)
+      };
+    }
+    case "record": {
+      const record = wire.record;
+      if (!isJsonValue(record)) throw new TypeError(`${path}.record is missing`);
+      return { item: "record", coordinates, record };
+    }
+    case "rejected":
+      return {
+        item: "rejected",
+        coordinates,
+        reason: wireString(wire.reason, `${path}.reason`),
+        message: wireString(wire.message, `${path}.message`)
+      };
+  }
+}
+function ImportCellNoteFromApiToFront(dto) {
+  const out = {
+    column: dto.column,
+    disposition: dto.disposition,
+    reason: dto.reason
+  };
+  if (present(dto.resource_key)) out.resourceKey = dto.resource_key;
+  return out;
+}
+function ImportItemFromApiToFront(dto) {
+  const out = {
+    ordinal: dto.ordinal,
+    coordinates: ImportCoordinatesFromWire(dto.coordinates, "coordinates"),
+    item: SourceItemFromWire(dto.item, "item"),
+    disposition: dto.disposition,
+    resourceKeys: dto.resource_keys,
+    notes: dto.notes.map(ImportCellNoteFromApiToFront)
+  };
+  if (present(dto.reason)) out.reason = dto.reason;
+  if (present(dto.target_record_id)) out.targetRecordId = dto.target_record_id;
+  return out;
+}
+function VocabularyImportItemPageFromApiToFront(dto) {
+  const out = {
+    importId: dto.import_id,
+    items: dto.items.map(ImportItemFromApiToFront),
+    complete: dto.complete
+  };
+  if (present(dto.next_cursor)) out.nextCursor = dto.next_cursor;
+  return out;
+}
+function LegacySortInventoryFromApiToFront(dto) {
+  return {
+    sortId: dto.sort_id,
+    sortName: dto.sort_name,
+    classification: dto.classification,
+    parents: dto.parents,
+    featureCount: dto.feature_count,
+    boundConstraintCount: dto.bound_constraint_count,
+    instances: dto.instances,
+    rulesReferencing: dto.rules_referencing,
+    featuresRangingOver: dto.features_ranging_over
+  };
+}
+function VocabularyMigrationPlanFromApiToFront(dto) {
+  return {
+    planId: dto.plan_id,
+    fingerprint: dto.fingerprint,
+    byteSize: dto.byte_size,
+    inventory: dto.inventory.map(LegacySortInventoryFromApiToFront),
+    dispositions: dto.dispositions.map(
+      (planned) => ({
+        sortId: planned.sort_id,
+        disposition: planned.disposition,
+        rationale: planned.rationale
+      })
+    ),
+    createdBy: dto.created_by,
+    createdAt: dto.created_at,
+    replayed: dto.replayed
+  };
+}
+function NativeExportManifestFromApiToFront(dto) {
+  const out = {
+    recordCount: dto.record_count,
+    countsByKind: dataMap(dto.counts_by_kind),
+    recordsSha256: dto.records_sha256,
+    unreadable: dto.unreadable.map((record) => ({
+      recordId: record.record_id,
+      reason: record.reason
+    }))
+  };
+  if (present(dto.context_manifest)) {
+    out.contextManifest = ContextManifestFromApiToFront(dto.context_manifest);
+  }
+  return out;
+}
+function VocabularyNativeExportFromApiToFront(dto) {
+  const out = {
+    format: dto.format,
+    view: ViewRefFromApiToFront(dto.view),
+    records: dto.records.map(VocabularyRecordViewFromApiToFront),
+    artifacts: dto.artifacts.map(VocabularySourceArtifactRecordFromApiToFront),
+    manifest: NativeExportManifestFromApiToFront(dto.manifest)
+  };
+  if (present(dto.context)) out.context = VocabularyContextRefFromApiToFront(dto.context);
+  return out;
+}
+function IriChoiceFromApiToFront(dto) {
+  return {
+    recordId: dto.record_id,
+    kind: dto.kind,
+    iri: dto.iri,
+    rule: dto.rule,
+    sourceAssociations: dto.source_associations
+  };
+}
+function ProjectionLossFromApiToFront(dto) {
+  return { kind: dto.kind, reason: dto.reason, recordIds: dto.record_ids };
+}
+function SkosManifestFromApiToFront(dto) {
+  const out = {
+    projection: dto.projection,
+    iriPolicy: dto.iri_policy,
+    view: ViewRefFromApiToFront(dto.view),
+    schemeId: dto.scheme_id,
+    includeProvenance: dto.include_provenance,
+    tripleCount: dto.triple_count,
+    iris: dto.iris.map(IriChoiceFromApiToFront),
+    losses: dto.losses.map(ProjectionLossFromApiToFront)
+  };
+  if (present(dto.context_id)) out.contextId = dto.context_id;
+  return out;
+}
+function VocabularySkosExportFromApiToFront(dto) {
+  return {
+    mediaType: dto.media_type,
+    content: dto.content,
+    sha256: dto.sha256,
+    manifest: SkosManifestFromApiToFront(dto.manifest)
+  };
+}
+function SparqlDatasetFromApiToFront(dto) {
+  const out = {
+    view: ViewRefFromApiToFront(dto.view),
+    schemeId: dto.scheme_id,
+    projection: dto.projection,
+    tripleCount: dto.triple_count
+  };
+  if (present(dto.context_id)) out.contextId = dto.context_id;
+  return out;
+}
+var SPARQL_TERM_TYPES = ["uri", "bnode", "literal"];
+function SparqlTermFromWire(value, path) {
+  const wire = wireObject(value, path);
+  const type = wireLiteral(wire.type, SPARQL_TERM_TYPES, `${path}.type`);
+  const lexical = wireString(wire.value, `${path}.value`);
+  switch (type) {
+    case "uri":
+      return { type: "uri", value: lexical };
+    case "bnode":
+      return { type: "bnode", value: lexical };
+    case "literal": {
+      const term = {
+        type: "literal",
+        value: lexical
+      };
+      const language = wire["xml:lang"];
+      if (present(language)) term["xml:lang"] = wireString(language, `${path}.xml:lang`);
+      if (present(wire.datatype)) term.datatype = wireString(wire.datatype, `${path}.datatype`);
+      return term;
+    }
+  }
+}
+function SparqlSelectDocumentFromWire(value) {
+  const wire = wireObject(value, "results");
+  const head = wireObject(wire.head, "results.head");
+  const results = wireObject(wire.results, "results.results");
+  return {
+    head: { vars: wireStringArray(head.vars, "results.head.vars") },
+    results: {
+      bindings: wireArray(results.bindings, "results.results.bindings").map((solution, index) => {
+        const path = `results.results.bindings[${index}]`;
+        const binding = {};
+        for (const [variable, term] of Object.entries(wireObject(solution, path))) {
+          binding[variable] = SparqlTermFromWire(term, `${path}.${variable}`);
+        }
+        return binding;
+      })
+    }
+  };
+}
+function SparqlAskDocumentFromWire(value) {
+  const wire = wireObject(value, "results");
+  wireObject(wire.head, "results.head");
+  return { head: {}, boolean: wireBoolean(wire.boolean, "results.boolean") };
+}
+function VocabularySparqlResultFromApiToFront(dto) {
+  const base = {
+    dataset: SparqlDatasetFromApiToFront(dto.dataset),
+    complete: dto.complete
+  };
+  if (present(dto.stop_reason)) base.stopReason = dto.stop_reason;
+  switch (dto.form) {
+    case "select":
+      return { ...base, form: "select", results: SparqlSelectDocumentFromWire(dto.results) };
+    case "ask":
+      return { ...base, form: "ask", results: SparqlAskDocumentFromWire(dto.results) };
+    case "construct":
+    case "describe": {
+      const nTriples = dto.n_triples;
+      if (!present(nTriples)) throw new TypeError("n_triples is missing from a graph answer");
+      return { ...base, form: dto.form, nTriples };
+    }
+  }
+}
 
 // src/resources/vocabulary.ts
 function viewQuery(selector) {
@@ -71102,6 +73501,681 @@ var VocabularyClient = class {
     const response = await this.api.migrationPreview(pageQuery(query), toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
     return decodeResponse(response, VocabularyMigrationPreviewFromApiToFront);
   }
+  // ---------------------------------------------------------------------------
+  // Taxonomy and thesaurus reads
+  // ---------------------------------------------------------------------------
+  /**
+   * The `broader` links of one scheme around a concept, or below its top
+   * concepts: a DAG of concepts and the stored relations that witness them.
+   *
+   * @param schemeId - The scheme (UUID); only its relations are followed.
+   * @param query - The view, a start concept, the direction, transitivity,
+   *   hierarchy kinds, a status, `maxNodes` (1 to 100000) and a display language.
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The nodes (each once, with every relation that reaches it in
+   *   `via`), the edges, and `complete` / `stopReason`.
+   * @throws {@link NotFoundError} 404 for an unknown scheme, concept, release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/schemes/{scheme_id}/hierarchy`. `hierarchyKinds`
+   * is sent as one comma-separated parameter. A traversal that reaches
+   * `maxNodes` or the deadline answers `complete: false` with its
+   * `stopReason`: a partial answer, not an error. Read `complete` before
+   * concluding that a concept is absent. Mappings are never followed.
+   *
+   * @example
+   * ```typescript
+   * const tree = await client.vocabulary.schemeHierarchy(schemeId, { transitive: true });
+   * if (!tree.complete) console.log('partial:', tree.stopReason);
+   * for (const node of tree.nodes) console.log(node.depth, node.displayLabel?.text, node.via);
+   * ```
+   */
+  async schemeHierarchy(schemeId, query, requestOptions) {
+    const wire = viewQuery(query?.view);
+    if (query?.conceptId !== void 0) wire.concept_id = query.conceptId;
+    if (query?.direction !== void 0) wire.direction = query.direction;
+    if (query?.transitive !== void 0) wire.transitive = query.transitive;
+    if (query?.hierarchyKinds !== void 0) wire.hierarchy_kinds = query.hierarchyKinds.join(",");
+    if (query?.status !== void 0) wire.status = query.status;
+    if (query?.maxNodes !== void 0) wire.max_nodes = query.maxNodes;
+    if (query?.language !== void 0) wire.language = query.language;
+    const response = await this.api.schemeHierarchy(schemeId, wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyHierarchyFromApiToFront);
+  }
+  /**
+   * The simple paths of accepted `broader` links from a narrower concept up
+   * to a broader one.
+   *
+   * @param schemeId - The scheme (UUID).
+   * @param query - The view, `from` and `to` (UUIDs), hierarchy kinds,
+   *   `maxNodes` (1 to 100000) and `maxPaths` (1 to 1024).
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns Each path as a sequence of relation ids, shortest first, and
+   *   `complete` / `stopReason`.
+   * @throws {@link NotFoundError} 404 for an unknown scheme, concept, release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/schemes/{scheme_id}/paths`. An empty `paths`
+   * with `complete: true` means no path exists; with `complete: false` it
+   * means the search stopped (`path_limit`, `node_limit` or `deadline`).
+   *
+   * @example
+   * ```typescript
+   * const { paths, complete } = await client.vocabulary.schemePaths(schemeId, {
+   *   from: narrowerId,
+   *   to: broaderId,
+   * });
+   * ```
+   */
+  async schemePaths(schemeId, query, requestOptions) {
+    const wire = {
+      ...viewQuery(query.view),
+      from: query.from,
+      to: query.to
+    };
+    if (query.hierarchyKinds !== void 0) wire.hierarchy_kinds = query.hierarchyKinds.join(",");
+    if (query.maxNodes !== void 0) wire.max_nodes = query.maxNodes;
+    if (query.maxPaths !== void 0) wire.max_paths = query.maxPaths;
+    const response = await this.api.schemePaths(schemeId, wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyHierarchyPathsFromApiToFront);
+  }
+  /**
+   * The top concepts of a scheme: the concepts with an accepted membership
+   * marked `topConcept`.
+   *
+   * @param schemeId - The scheme (UUID).
+   * @param query - The view and a display language.
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The concepts, by id.
+   * @throws {@link NotFoundError} 404 for an unknown scheme, release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/schemes/{scheme_id}/top-concepts`.
+   *
+   * @example
+   * ```typescript
+   * const { concepts } = await client.vocabulary.topConcepts(schemeId, { language: 'en' });
+   * ```
+   */
+  async topConcepts(schemeId, query, requestOptions) {
+    const wire = viewQuery(query?.view);
+    if (query?.language !== void 0) wire.language = query.language;
+    const response = await this.api.schemeTopConcepts(schemeId, wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyTopConceptsFromApiToFront);
+  }
+  /**
+   * The taxonomy policy of a scheme, or the `taxonomy-policy/v1` defaults
+   * with `declared: false`.
+   *
+   * @param schemeId - The scheme (UUID).
+   * @param query - The view.
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The policy in force for the scheme in that view.
+   * @throws {@link NotFoundError} 404 for an unknown scheme, release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/schemes/{scheme_id}/policy`. An absent
+   * `partitiveTransitive` is unstated: a partitive path of two or more links
+   * is reported, never derived.
+   *
+   * @example
+   * ```typescript
+   * const policy = await client.vocabulary.schemePolicy(schemeId);
+   * if (!policy.declared) console.log('defaults', policy.policy);
+   * ```
+   */
+  async schemePolicy(schemeId, query, requestOptions) {
+    const response = await this.api.schemePolicy(schemeId, viewQuery(query?.view), toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyTaxonomyPolicyFromApiToFront);
+  }
+  /**
+   * The direct relations of one kind of a concept in one scheme, of every
+   * status.
+   *
+   * @param conceptId - The concept (UUID).
+   * @param query - The view, the scheme, `relation` (`related`, `broader` or
+   *   `narrower`) and a display language.
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The relations, by relation id, each with the concept at the other end.
+   * @throws {@link NotFoundError} 404 for an unknown concept, scheme, release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/concepts/{concept_id}/relations`. `narrower` is
+   * the inverse read of the stored `broader` links; nothing derived is listed.
+   *
+   * @example
+   * ```typescript
+   * const { relations } = await client.vocabulary.conceptRelations(conceptId, {
+   *   schemeId,
+   *   relation: 'narrower',
+   * });
+   * ```
+   */
+  async conceptRelations(conceptId, query, requestOptions) {
+    const wire = {
+      ...viewQuery(query.view),
+      scheme_id: query.schemeId,
+      relation: query.relation
+    };
+    if (query.language !== void 0) wire.language = query.language;
+    const response = await this.api.conceptRelations(conceptId, wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyConceptRelationsFromApiToFront);
+  }
+  /**
+   * One page of the collections of one scheme.
+   *
+   * @param query - The view, the scheme and cursor paging (`limit` 1 to 200).
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The collections with their labels and member counts, the next
+   *   cursor and `complete`.
+   * @throws {@link NotFoundError} 404 for an unknown scheme, release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`,
+   *   `cursor_mismatch` (a cursor read with another view or scheme); 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/collections?scheme_id&cursor&limit`. A cursor is
+   * bound to the tenant, the view and the scheme.
+   *
+   * @example
+   * ```typescript
+   * const page = await client.vocabulary.listCollections({ schemeId, limit: 50 });
+   * ```
+   */
+  async listCollections(query, requestOptions) {
+    const wire = {
+      ...viewQuery(query.view),
+      ...pageQuery(query),
+      scheme_id: query.schemeId
+    };
+    const response = await this.api.listVocabularyCollections(wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyCollectionPageFromApiToFront);
+  }
+  /**
+   * One collection with its labels, its member occurrences and its nested
+   * collections.
+   *
+   * @param collectionId - The collection (UUID).
+   * @param query - The view and a display language for member concepts.
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The collection detail. Member occurrences keep their positions.
+   * @throws {@link NotFoundError} 404 when the view does not hold the collection.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/collections/{collection_id}`. Members are listed
+   * by position (absent first), then by occurrence id; a member that occurs
+   * twice is listed twice.
+   *
+   * @example
+   * ```typescript
+   * const detail = await client.vocabulary.getCollection(collectionId, { language: 'en' });
+   * for (const member of detail.members) console.log(member.position, member.memberConcept);
+   * ```
+   */
+  async getCollection(collectionId, query, requestOptions) {
+    const wire = viewQuery(
+      query?.view
+    );
+    if (query?.language !== void 0) wire.language = query.language;
+    const response = await this.api.getVocabularyCollection(collectionId, wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyCollectionDetailFromApiToFront);
+  }
+  /**
+   * One page of the depth-first list of a scheme's concepts, for a form
+   * control. A concept with several parents is listed once.
+   *
+   * @param schemeId - The scheme (UUID).
+   * @param query - The view, a root, `maxDepth`, `maxNodes` (1 to 100000),
+   *   a display language and cursor paging (`limit` 1 to 500).
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The entries of this page, the roots, the next cursor,
+   *   `complete` and `stopReason`.
+   * @throws {@link NotFoundError} 404 for an unknown scheme, root, release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`,
+   *   `cursor_mismatch`; 409 `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/schemes/{scheme_id}/picklist`. Only accepted
+   * `broader` relations are followed. `complete` is `true` only on the last
+   * page of a list that `maxNodes` did not cut.
+   *
+   * @example
+   * ```typescript
+   * let page = await client.vocabulary.picklist(schemeId, { limit: 100 });
+   * while (page.nextCursor !== undefined) {
+   *   page = await client.vocabulary.picklist(schemeId, { cursor: page.nextCursor });
+   * }
+   * ```
+   */
+  async picklist(schemeId, query, requestOptions) {
+    const wire = {
+      ...viewQuery(query?.view),
+      ...pageQuery(query)
+    };
+    if (query?.root !== void 0) wire.root = query.root;
+    if (query?.maxDepth !== void 0) wire.max_depth = query.maxDepth;
+    if (query?.maxNodes !== void 0) wire.max_nodes = query.maxNodes;
+    if (query?.language !== void 0) wire.language = query.language;
+    const response = await this.api.schemePicklist(schemeId, wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyPicklistFromApiToFront);
+  }
+  /**
+   * The concepts a query on one concept may be expanded to, each with the
+   * relation and mapping ids that support it.
+   *
+   * @param conceptId - The concept to expand (UUID).
+   * @param query - The view, the scheme, the direction, transitivity,
+   *   hierarchy kinds, related links, mapping kinds, `maxNodes` and a display
+   *   language.
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The concepts and external concepts with their support, the
+   *   withheld relations and `complete` / `stopReason`.
+   * @throws {@link NotFoundError} 404 for an unknown concept, scheme, release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/concepts/{concept_id}/expansion`.
+   * `hierarchyKinds` and `mappingKinds` are sent comma-separated. A
+   * partitive link that would end a transitive path is not followed unless
+   * the scheme's policy states `partitiveTransitive: true`; it is listed in
+   * `withheldRelationIds`.
+   *
+   * @example
+   * ```typescript
+   * const expansion = await client.vocabulary.expandConcept(conceptId, {
+   *   schemeId,
+   *   transitive: true,
+   *   mappingKinds: ['exact', 'close'],
+   * });
+   * ```
+   */
+  async expandConcept(conceptId, query, requestOptions) {
+    const wire = {
+      ...viewQuery(query.view),
+      scheme_id: query.schemeId
+    };
+    if (query.direction !== void 0) wire.direction = query.direction;
+    if (query.transitive !== void 0) wire.transitive = query.transitive;
+    if (query.hierarchyKinds !== void 0) wire.hierarchy_kinds = query.hierarchyKinds.join(",");
+    if (query.includeRelated !== void 0) wire.include_related = query.includeRelated;
+    if (query.mappingKinds !== void 0) wire.mapping_kinds = query.mappingKinds.join(",");
+    if (query.maxNodes !== void 0) wire.max_nodes = query.maxNodes;
+    if (query.language !== void 0) wire.language = query.language;
+    const response = await this.api.conceptExpansion(conceptId, wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyExpansionFromApiToFront);
+  }
+  // ---------------------------------------------------------------------------
+  // Imports
+  // ---------------------------------------------------------------------------
+  /**
+   * Parse an uploaded source file and store its import proposal. Writes no
+   * vocabulary record.
+   *
+   * @param request - The uploaded file, its format, the declared dataset, the
+   *   target scheme and the RDF options.
+   * @param requestOptions - The required `idempotencyKey` and per-call options.
+   * @returns The import: artefact identity, completeness, item counts by
+   *   disposition, reconciliation entries and proposed record counts.
+   * @throws {@link VocabularyRefusedError} 403 `vocabulary_actor_required`,
+   *   `vocabulary_authority_denied`, `vocabulary_authority_undetermined`; 404
+   *   `source_file_not_found`; 409 `vocabulary_plugin_unavailable`; 413
+   *   `source_too_large` (over 20 MiB); 422 `format_unsupported`,
+   *   `invalid_request`.
+   * @throws {@link IdempotencyKeyReusedError} 422 when the key committed a different request.
+   * @throws {@link MutationOutcomeUnconfirmedError} 503 when the commit outcome is unknown.
+   *
+   * @remarks
+   * `POST /api/v1/vocabulary/imports` with `Idempotency-Key`. Upload the file
+   * first with `client.sources.uploadFile` and pass its id. Permission
+   * `author_vocabulary` on the tenant. An incomplete parse
+   * (`complete: false`) can be read and paged, never committed. Recover an
+   * unknown outcome with {@link VocabularyClient.getRequestOutcome}
+   * (`'create_import'`).
+   *
+   * @example
+   * ```typescript
+   * const key = crypto.randomUUID(); // bind once; pass the same key on every retry
+   * const file = await client.sources.uploadFile(new Blob([turtle]), 'scheme.ttl');
+   * const proposal = await client.vocabulary.createImport(
+   *   {
+   *     sourceFileId: file.id,
+   *     format: 'turtle',
+   *     dataset: 'https://example.org/scheme',
+   *     targetScheme: { existing: { schemeId } },
+   *   },
+   *   { idempotencyKey: key },
+   * );
+   * ```
+   */
+  async createImport(request, requestOptions) {
+    const response = await this.api.createImport(
+      CreateVocabularyImportRequestFromFrontToApi(request),
+      idempotencyParams(requestOptions.idempotencyKey, requestOptions)
+    ).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyImportFromApiToFront);
+  }
+  /**
+   * One import proposal.
+   *
+   * @param importId - The import (UUID).
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The import, with `committedRevisionId` once committed.
+   * @throws {@link NotFoundError} 404 for an unknown import.
+   * @throws {@link VocabularyRefusedError} 409 `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/imports/{import_id}`.
+   *
+   * @example
+   * ```typescript
+   * const proposal = await client.vocabulary.getImport(importId);
+   * ```
+   */
+  async getImport(importId, requestOptions) {
+    const response = await this.api.getImport(importId, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyImportFromApiToFront);
+  }
+  /**
+   * One page of an import's source items, by ordinal: what was read, where,
+   * and what became of it.
+   *
+   * @param importId - The import (UUID).
+   * @param query - A disposition filter and cursor paging (`limit` 1 to 500).
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The items, the next cursor and `complete`.
+   * @throws {@link NotFoundError} 404 for an unknown import.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request` (a malformed
+   *   cursor or limit); 409 `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/imports/{import_id}/items`. Nothing read is
+   * dropped: a malformed part is a `rejected` item with its coordinates.
+   *
+   * @example
+   * ```typescript
+   * const rejected = await client.vocabulary.listImportItems(importId, {
+   *   disposition: 'rejected',
+   * });
+   * ```
+   */
+  async listImportItems(importId, query, requestOptions) {
+    const wire = pageQuery(query);
+    if (query?.disposition !== void 0) wire.disposition = query.disposition;
+    const response = await this.api.importItems(importId, wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyImportItemPageFromApiToFront);
+  }
+  /**
+   * Commit an import proposal with the reviewer's decisions as one candidate
+   * revision: a new candidate, or the next revision of `candidateId`.
+   *
+   * @param importId - The import (UUID).
+   * @param request - The change reason, a title (new candidate) or a
+   *   `candidateId`, and one decision per reconciliation entry.
+   * @param requestOptions - The required `idempotencyKey`, `ifMatch` when
+   *   `candidateId` is given, and per-call options.
+   * @returns The candidate revision the import became.
+   * @throws {@link PreconditionFailedError} 412 when `ifMatch` is not the head.
+   * @throws {@link NotFoundError} 404 for an unknown import or candidate.
+   * @throws {@link VocabularyRefusedError} 409 `import_incomplete`,
+   *   `import_already_committed`, `import_baseline_stale`,
+   *   `active_release_changed`, `candidate_closed`; 422
+   *   `reconciliation_undecided` (see `refusal.undecidedSourceKeys`),
+   *   `invalid_decision`, `import_too_large`, `invalid_records`; 428
+   *   `if_match_required`; 403 authority.
+   * @throws {@link IdempotencyKeyReusedError} 422.
+   * @throws {@link MutationOutcomeUnconfirmedError} 503.
+   *
+   * @remarks
+   * `POST /api/v1/vocabulary/imports/{import_id}/commit` with
+   * `Idempotency-Key` (and `If-Match` with `candidateId`). Source keys travel
+   * as values, verbatim. The revision is a candidate: steward review,
+   * approval, release and activation still apply. Recover an unknown outcome
+   * with {@link VocabularyClient.getRequestOutcome} (`'commit_import'`).
+   *
+   * @example
+   * ```typescript
+   * const key = crypto.randomUUID(); // bind once; pass the same key on every retry
+   * const revision = await client.vocabulary.commitImport(
+   *   importId,
+   *   {
+   *     title: 'Import the manufacturing scheme',
+   *     changeReason: 'Adopt the reviewed source',
+   *     decisions: proposal.reconciliation.map((entry) => ({
+   *       sourceKey: entry.sourceKey,
+   *       decision: 'create_new',
+   *     })),
+   *   },
+   *   { idempotencyKey: key },
+   * );
+   * ```
+   */
+  async commitImport(importId, request, requestOptions) {
+    const response = await this.api.commitImport(
+      importId,
+      CommitVocabularyImportRequestFromFrontToApi(request),
+      idempotencyParams(requestOptions.idempotencyKey, requestOptions, requestOptions.ifMatch)
+    ).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyCandidateRevisionFromApiToFront);
+  }
+  // ---------------------------------------------------------------------------
+  // Migration plans
+  // ---------------------------------------------------------------------------
+  /**
+   * Store the reviewer's dispositions of legacy sorts over the current legacy
+   * inventory. Converts nothing.
+   *
+   * @param request - One disposition per planned sort.
+   * @param requestOptions - The required `idempotencyKey` and per-call options.
+   * @returns The plan, with the fingerprint and per-sort usage of the inventory it binds.
+   * @throws {@link VocabularyRefusedError} 422 `invalid_disposition` (a
+   *   `formal_in_use` sort planned `convert_lexical`), `invalid_request`; 400
+   *   `read_budget_exceeded`; 403 authority; 409 `vocabulary_plugin_unavailable`.
+   * @throws {@link IdempotencyKeyReusedError} 422.
+   * @throws {@link MutationOutcomeUnconfirmedError} 503.
+   *
+   * @remarks
+   * `POST /api/v1/vocabulary/migration/plans` with `Idempotency-Key`. Read the
+   * inventory first with {@link VocabularyClient.migrationPreview}. Recover an
+   * unknown outcome with {@link VocabularyClient.getRequestOutcome}
+   * (`'create_migration_plan'`).
+   *
+   * @example
+   * ```typescript
+   * const key = crypto.randomUUID(); // bind once; pass the same key on every retry
+   * const plan = await client.vocabulary.createMigrationPlan(
+   *   { dispositions: [{ sortId, disposition: 'convert_lexical', rationale: 'Labels only' }] },
+   *   { idempotencyKey: key },
+   * );
+   * ```
+   */
+  async createMigrationPlan(request, requestOptions) {
+    const response = await this.api.createMigrationPlan(
+      CreateVocabularyMigrationPlanRequestFromFrontToApi(request),
+      idempotencyParams(requestOptions.idempotencyKey, requestOptions)
+    ).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyMigrationPlanFromApiToFront);
+  }
+  /**
+   * One migration plan.
+   *
+   * @param planId - The plan (UUID).
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The plan.
+   * @throws {@link NotFoundError} 404 for an unknown plan.
+   * @throws {@link VocabularyRefusedError} 409 `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/migration/plans/{plan_id}`.
+   *
+   * @example
+   * ```typescript
+   * const plan = await client.vocabulary.getMigrationPlan(planId);
+   * ```
+   */
+  async getMigrationPlan(planId, requestOptions) {
+    const response = await this.api.getMigrationPlan(planId, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyMigrationPlanFromApiToFront);
+  }
+  /**
+   * Apply a migration plan as a new candidate on the active release.
+   *
+   * @param planId - The plan (UUID).
+   * @param request - The title, the change reason, the target scheme and the
+   *   language of the legacy labels.
+   * @param requestOptions - The required `idempotencyKey` and per-call options.
+   * @returns The candidate revision: concepts, the `legacy_theory` artefact,
+   *   source associations and one `migration_decision` per planned sort.
+   * @throws {@link NotFoundError} 404 for an unknown plan.
+   * @throws {@link VocabularyRefusedError} 409 `migration_plan_stale` (the
+   *   legacy inventory changed; see `refusal.changedSorts`),
+   *   `active_release_changed`; 422 `invalid_records`, `import_too_large`;
+   *   403 authority.
+   * @throws {@link IdempotencyKeyReusedError} 422.
+   * @throws {@link MutationOutcomeUnconfirmedError} 503.
+   *
+   * @remarks
+   * `POST /api/v1/vocabulary/migration/plans/{plan_id}/apply` with
+   * `Idempotency-Key`. No sort is converted, removed or reparented: the
+   * candidate holds governed records only, and it still needs review,
+   * approval, release and activation. Without `defaultLanguage` no label is
+   * written. Recover an unknown outcome with
+   * {@link VocabularyClient.getRequestOutcome} (`'apply_migration_plan'`).
+   *
+   * @example
+   * ```typescript
+   * const key = crypto.randomUUID(); // bind once; pass the same key on every retry
+   * const revision = await client.vocabulary.applyMigrationPlan(
+   *   plan.planId,
+   *   {
+   *     title: 'Migrate the legacy vocabulary',
+   *     changeReason: 'Plan reviewed',
+   *     scheme: { existing: { schemeId } },
+   *     defaultLanguage: 'en',
+   *   },
+   *   { idempotencyKey: key },
+   * );
+   * ```
+   */
+  async applyMigrationPlan(planId, request, requestOptions) {
+    const response = await this.api.applyMigrationPlan(
+      planId,
+      ApplyVocabularyMigrationPlanRequestFromFrontToApi(request),
+      idempotencyParams(requestOptions.idempotencyKey, requestOptions)
+    ).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyCandidateRevisionFromApiToFront);
+  }
+  // ---------------------------------------------------------------------------
+  // Exports and SPARQL
+  // ---------------------------------------------------------------------------
+  /**
+   * The records of a view as `kos-json/v1`, with the source preservation
+   * inventory and a manifest.
+   *
+   * @param query - The view; the active release when absent.
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns Every readable record by id, every `source_artifact` record, and
+   *   the manifest (record count, counts by kind, records digest, the records
+   *   that could not be read, the stored context manifest).
+   * @throws {@link NotFoundError} 404 for an unknown release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/exports/native`. A record that does not parse as
+   * its kind is listed in `manifest.unreadable`, never dropped silently.
+   *
+   * @example
+   * ```typescript
+   * const exported = await client.vocabulary.exportNative();
+   * console.log(exported.manifest.recordCount, exported.manifest.unreadable.length);
+   * ```
+   */
+  async exportNative(query, requestOptions) {
+    const response = await this.api.exportNative(viewQuery(query?.view), toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularyNativeExportFromApiToFront);
+  }
+  /**
+   * The SKOS projection of one scheme as Turtle or RDF/XML, with its
+   * manifest: the IRI of every published record and what the projection does
+   * not express.
+   *
+   * @param query - The view, the scheme, the RDF syntax and `includeProvenance`.
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The content, its media type, its SHA-256 and the manifest.
+   * @throws {@link NotFoundError} 404 for an unknown scheme, release or revision.
+   * @throws {@link VocabularyRefusedError} 400 `invalid_request`; 409
+   *   `vocabulary_plugin_unavailable`; 422 `export_unrepresentable`.
+   *
+   * @remarks
+   * `GET /api/v1/vocabulary/exports/skos` (`skos-projection/v1`,
+   * `concept-iri/v1`). Read `manifest.losses` before treating the content as
+   * the whole vocabulary: governance records, evidence and other schemes are
+   * not projected.
+   *
+   * @example
+   * ```typescript
+   * const skos = await client.vocabulary.exportSkos({ schemeId, format: 'turtle' });
+   * for (const loss of skos.manifest.losses) console.log(loss.kind, loss.recordIds.length);
+   * ```
+   */
+  async exportSkos(query, requestOptions) {
+    const wire = {
+      ...viewQuery(query.view),
+      scheme_id: query.schemeId
+    };
+    if (query.format !== void 0) wire.format = query.format;
+    if (query.includeProvenance !== void 0) wire.include_provenance = query.includeProvenance;
+    const response = await this.api.exportSkos(wire, toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularySkosExportFromApiToFront);
+  }
+  /**
+   * One read-only SPARQL query over the SKOS projection of one scheme of one
+   * view.
+   *
+   * @param request - The query, the scheme, the view and `maxResults` (1 to 100000).
+   * @param requestOptions - Per-call options (timeout, retries, signal, headers).
+   * @returns The answer, discriminated by `form`: the W3C results document
+   *   for `select` and `ask`, N-Triples for `construct` and `describe`; the
+   *   dataset it was computed over; `complete` and `stopReason`.
+   * @throws {@link VocabularyRefusedError} 400 `sparql_unsupported` (an
+   *   update, a `SERVICE` clause or a `FROM`/`FROM NAMED` clause),
+   *   `invalid_request` (a query that does not parse); 422
+   *   `export_unrepresentable` (the projection holds a value the dataset
+   *   cannot load); 503 `vocabulary_sparql_unavailable`, `sparql_deadline`
+   *   (no answer before the deadline); 409 `vocabulary_plugin_unavailable`.
+   * @throws {@link NotFoundError} 404 for an unknown scheme, release or revision.
+   *
+   * @remarks
+   * `POST /api/v1/vocabulary/sparql`. The query is a string value: the body
+   * transform never changes it. A reached `maxResults` or deadline answers
+   * `complete: false` with `stopReason`.
+   *
+   * @example
+   * ```typescript
+   * const answer = await client.vocabulary.sparql({
+   *   schemeId,
+   *   query: 'SELECT ?c WHERE { ?c a <http://www.w3.org/2004/02/skos/core#Concept> }',
+   * });
+   * if (answer.form === 'select') console.log(answer.results.results.bindings.length);
+   * ```
+   */
+  async sparql(request, requestOptions) {
+    const response = await this.api.sparqlQuery(VocabularySparqlRequestFromFrontToApi(request), toRequestParams(requestOptions)).catch(rethrowVocabularyRefusal);
+    return decodeResponse(response, VocabularySparqlResultFromApiToFront);
+  }
 };
 
 // src/normalizers/plugins.ts