Semantic Layer

Creates, searches, and manages semantic tables, templates, and dictionaries.

📄️ Create Table

Create a semantic table that maps a queryable resource to semantic columns, metrics, filters, and routing links.

List semantic-table version records after read permission is checked. When no history is available, the response is an empty array. Each record includes version identity, latest-version status, timestamps, operation, author, change summary, and storage-reference metadata.

📄️ Get Table

Return a semantic table definition with its columns, metrics, filters, routing links, and source binding.

📄️ Update Table

Update a semantic table (partial; omitted fields unchanged).

📄️ Delete Table

Permanently remove a semantic table definition so it is no longer available for semantic routing.

📄️ List Dictionaries

List semantic dictionaries the user can read.

📄️ Create Dictionary

Create a semantic dictionary resource that can store canonical values and their alternative surface forms.

📄️ List Dictionary Usages

Reverse-lookup of the semantic tables and ontologies binding this dictionary. A column references a dictionary by name (``Column.dictionary.external``), so the forward direction is visible on the table but the reverse is not — this returns every table (and the referencing column names) bound to ``dictionary_id``, so the UI can show where a dictionary is wired in. A semantic ontology's curated entity attribute holds the same reference and is listed alongside in ``ontologies``. Both empty means it is wired to nothing at all. ``total`` counts tables only, as it always has. Requires read permission on the dictionary; the referencing resources' permissions are not checked (usage visibility intent, mirroring ``GET /codes/{id}/usages``).

📄️ Get Dictionary

Return semantic dictionary metadata and its current item count.

📄️ Update Dictionary

Update a semantic dictionary (partial; omitted fields unchanged).

📄️ Delete Dictionary

Delete a semantic dictionary. Rejected (409) while a table references it.

📄️ List Dictionary Items

List dictionary items using `page` and `size`. Use `q` to match a substring in names, labels, and synonyms, and sort results by name or label.

📄️ Upsert Dictionary Items

Insert or update stored dictionary items using the requested `overwrite`, `merge`, or `skip` conflict policy, then schedule a best-effort refresh of the search data.

📄️ Replace Dictionary Items

Replace all stored items in a dictionary and schedule a best-effort refresh of its search data.

📄️ Update Dictionary Item

Update one item, including an atomic canonical-name rename.

📄️ Delete Dictionary Item

Remove the named canonical item and its synonyms. Other entries in the dictionary are retained.

📄️ List Templates

List semantic templates the user can read.

📄️ Create Template

Create a new semantic template (verified at write time: the query must render and compile against the bound table).

📄️ Get Template

Return a semantic template group with its reusable queries, slots, and computation code.

📄️ Update Template

Update a semantic template group (partial; omitted fields unchanged; ``templates`` replaces the whole item list). The merged group is re-verified against every item's bound table.

📄️ Delete Template

Permanently remove a semantic template group and its reusable computation templates.

📄️ Lookup Dictionary Codes

Which of ``pairs`` are canonical codes of their dictionary.

📄️ Search Dictionary

Return the nearest dictionary candidates for the supplied value.

📄️ List Ontologies

List semantic ontologies the user can read.

📄️ Create Ontology

Create a semantic ontology: import the model's structure (every entity and relation type, keys, attributes) and apply the curation lists. The resource lives in the model's collection.

📄️ Get Ontology

Return the semantic ontology built for a collection, including its curated entity types, relation types, and attributes.

📄️ Update Ontology

Update a semantic ontology (partial; omitted fields unchanged). The ``entities``/``relations`` lists curate the imported structure by name — they never add or remove types (that is ``sync``). Hiding an entity hides its relations; a relation set ``visible: true`` against a hidden endpoint is a 422 naming the endpoint. Unhiding an entity does not re-show its relations — set them visible explicitly.

📄️ Delete Ontology

Delete a semantic ontology (409 while an agent registers it).

📄️ Sync Ontology

Re-import the model's structure and merge the curation back by name: new types arrive with import defaults, types the model no longer has are kept as ``missing`` (forced hidden), every curation axis (``visible`` / ``description`` / ``dictionary`` / ``values`` / ``samples`` / ``display`` / ``comments``) survives. Needs ``read`` on the model and every imported type, like create.