@githonllc/avouch 0.1.3 → 0.1.5

package/README.md

@@ -34,6 +34,7 @@ Read in this order:
 |---|---|
 | `SPEC.md` | concepts (foundation / extension), fields, rules R1–R12, fact contract |
 | `ontology.schema.json` | JSON Schema: `$id` and `formatVersion`; shape only, no project values |
+| `vocab.ttl` | RDF vocabulary (`ofv:`) for exporting an ontology as RDF; one term per schema field (`test/vocab.test.ts`) |
 | `src/contract.ts` | `SourceFacts`: the facts with their sources, and diagnostics |
 | `src/checker.ts` | `check(ontology, facts)` returns the violations |
 | `src/patch.ts` | JSON-pointer patch that the mutation tests use |
@@ -130,7 +131,7 @@ Inside a Claude Code session, the same two steps are `/plugin marketplace add gi
 
 The plugin has two skills:
 - `cli` (`/avouch:cli`): checks an ontology and runs `avouch query`.
-- `scan` (`/avouch:scan [project-dir]`): drafts or updates a project's ontology from its design documents. The result is a candidate. `avouch check` must exit 0, and each source gap is listed with a proposed fix to the document.
+- `scan` (`/avouch:scan [project-dir]`): drafts or updates a project's ontology from its design documents. The result is a candidate. `avouch check` must exit 0, and each source gap is listed with a proposed fix to the document. When most objects have no documented field list, it also writes `avouch/doc-patch.md`: field lists, foreign keys and store names derived from the code, for a human to review and merge into the documents. It never drafts states, permissions or rules from code.
 
 Before 0.1.3 the two skills were named `avouch-cli` and `aquery-scan`.
 
@@ -159,6 +160,8 @@ The secret is generated from a list kept in a private repository; maintainers ne
 
 The ontology file has `formatVersion: 1`. The schema `$id` is `https://w3id.org/avouch/v1/schema.json`. The version rules are in SPEC section 8.
 
+The RDF vocabulary is `vocab.ttl`, namespace `https://w3id.org/avouch/v1/vocab#` (prefix `ofv:`), served at `https://avouch.dev/v1/vocab.ttl`. An RDF export of an ontology (for example the Turtle export of Avouch Studio) names each field with the term of the same name. The check does not read the vocabulary. A change that adds a schema field adds its term in the same change: `test/vocab.test.ts` fails on a field without a term, except for the top-level sections, expressions (exported as one JSON literal), the `properties` of an object type (OWL properties) and the `ref` of a value type (the class itself); each exclusion has its reason in the test.
+
 ## License
 
 Copyright 2026 Githon LLC. Licensed under the Apache License 2.0. See `LICENSE` and `NOTICE`. The next section gives the exception.

package/SPEC.md

@@ -49,7 +49,7 @@ The definitions quoted in the "Palantir analog" column are short quotations from
 | `actionTypes.<A>.parameters` | foundation | action parameter: "Parameters are the inputs of an action type." | name → `{cite, type?, optional?, values?}`; read by a condition as `{param}` or, in an expression, `{ref}`; `type` is needed when an expression reads it; `optional: true` lets the caller omit it; `values` (only with `type: enum`) is the value domain of the parameter; R1, R2 |
 | `conditions` | foundation + constraint | submission criteria: "the conditions that determine whether an action can be submitted"; Palantir submission criteria ≈ the rows whose disposition class is `rejected` | named Boolean claims `{id, expr \| unspecified, reads?, reads_unspecified?, cites[{cite}], scenarios?}`: `expr` is the claim as an expression (section 9); `unspecified` says it is not written as one, and `reads` may then list what it reads (properties, parameters `{param, values?}`, the caller `{actor: id}` / `{actor: keys}`); R1, R4, R12 |
 | `decision` | extension | none | decision table `{hitPolicy: first, order?: {cite}, rows: [{when: {passes \| fails: <condition>}, result, cites, next?}], otherwise?: {result, cites, next?}}`; `next` is `{actions}`, `{external, cite}` or `{unspecified}`; R1, R12 |
-| `edits` / `creates` | foundation | action rules: modify / create object | |
+| `edits` / `creates` / `deletes` | foundation | action rules: modify / create / delete object | `deletes` is a hard delete of datasource rows; a soft delete is an `edits` |
 | `link_effects` | foundation + constraint | action rules: create / delete link | every incident link needs an entry, including `none` / `unspecified` (R6 sweep) |
 | `emits` | extension | none (Palantir side effects are notifications / webhooks after submission) | events written in the same operation; R7, R8 |
 | `permission` | extension | roles / submission criteria on the current user are approximate. Forms: `unknown`, `{keys, cite, …}`, `{none, cite}` (optionally with `principals`), `{any_of: [keys-form, …]}` (OR of keys-forms, at least 2) | R1, R10 |
@@ -110,11 +110,11 @@ The adapter may read the ontology instance (for example to list action ids in a
 | R4 | conditions read only canonical and policy properties, for an expression also through the derived properties it reaches (parameter and actor reads are request inputs, not state, and are not classified; a derived property without `expr` is not expanded; a hand-written `reads` entry that names a derived property is expanded through its `reads`, or, when it has an `expr`, through the properties that expression reads, as for an expression condition); a non-canonical property passes when every read compares it by `eq` / `neq` with a literal in its `canonical_values`; canonical values and the values of a parameter read appear in their quote (`parameter_value_unsupported`); each literal of an expression appears in one of its condition's quotes, or in the derived property's quote (`literal_unsupported`, key `<ID>:<condition id>:<value>` or `derivedProperties.<id>:<value>`) | none | the property reads of conditions are canonical or policy facts; literals are not invented | that `reads` is complete; that an expression's logic matches its cite |
 | R5 | object membership, cross-context declaration (`via` or `unspecified`), `create_rule`, entity coverage | `contextMembers`, `config.crossContextMechanisms` | object ownership matches the source | the content of the mechanism |
 | R6 | link sweep, link catalog complete (with `scope`, the `<by>` field of a tenant type counts as declared and must not be in `non_link_fields`: `non_link_field_stray`), `none_but_written` | `fieldList`, `config.linkFieldPattern`, `evidence` | link effects are declared completely | that an effect text is right |
-| R7 | observed writes are declared; events are in `emits`; changed columns are declared (`column_undeclared`, key `<ID>:<Object>.<prop>`); declared effects are witnessed (`effect_unwitnessed`); with `config.evidenceRequired: true` (default `false`) an action without `evidence` fails `evidence_missing` (key `<ID>`) | `evidence`, `config.evidenceRequired` | every store changed by a committed invocation is in the touched objects' `datasource`, a pure link table with an `effect`, or `infrastructureStores`; every observed event is in `emits`; every column changed on an existing row of a touched object's `datasource` is, for each touched object of that store, a property of a resolvable `edits` entry of that same object (objects may share a store; a column that one object declares is still reported for each other touched object of the store that does not declare it); every resolvable `edits` entry (resolved as R1 resolves it; an unresolvable entry is R1 only) was changed on an existing row (key `<ID>:<Object>.<prop>`), every `creates` object had a row inserted (key `<ID>:creates:<Object>`) and every pure link table with an `effect` had a row inserted or deleted (key `<ID>:link:<link id>`) by at least one committed invocation | actions without evidence (unless `evidenceRequired`); that a not yet witnessed effect is unreachable; atomicity, which refers to the committed effect (one invocation may have several attempts) and which the project profile or evidence adapter must enforce |
+| R7 | observed writes are declared; events are in `emits`; changed columns are declared (`column_undeclared`, key `<ID>:<Object>.<prop>`); declared effects are witnessed (`effect_unwitnessed`); with `config.evidenceRequired: true` (default `false`) an action without `evidence` fails `evidence_missing` (key `<ID>`) | `evidence`, `config.evidenceRequired` | every store changed by a committed invocation is in the touched objects' `datasource`, a pure link table with an `effect`, or `infrastructureStores`; every observed event is in `emits`; every column changed on an existing row of a touched object's `datasource` is, for each touched object of that store, a property of a resolvable `edits` entry of that same object (objects may share a store; a column that one object declares is still reported for each other touched object of the store that does not declare it); every resolvable `edits` entry (resolved as R1 resolves it; an unresolvable entry is R1 only) was changed on an existing row (key `<ID>:<Object>.<prop>`), every `creates` object had a row inserted (key `<ID>:creates:<Object>`), every `deletes` object had a row deleted (key `<ID>:deletes:<Object>`) and every pure link table with an `effect` had a row inserted or deleted (key `<ID>:link:<link id>`) by at least one committed invocation | actions without evidence (unless `evidenceRequired`); that a not yet witnessed effect is unreachable; atomicity, which refers to the committed effect (one invocation may have several attempts) and which the project profile or evidence adapter must enforce |
 | R8 | emitted events are in the catalog | `eventCatalog` | | |
 | R9 | scenario cross references | `scenarios` | every action is cited; with `config.scenarioCoverage: "enforced"` (default `"printed"`, coverage only printed) every condition without `scenarios` fails `criterion_uncovered` (key `<ID>:<condition id>`) and every non-`none`, non-`unspecified` link effect without `scenarios` fails `effect_uncovered` (key `<ID>:<link id>`); `unspecified` effects are not reported again, R6 reports them | with `printed`, that scenarios cover every condition; that a listed scenario supports the claim |
 | R10 | permission key sets equal the source rows (for `any_of`: the union over alternatives of keys ∪ conditional_keys; each alternative's cite must also name its own keys); cites name the required source | `permissions`, `config.requiredSource.R10` | keys match the source | |
-| R11 | an action that edits an input lists the materialized property | none | declaration is complete | same-operation atomicity of the committed effect (one invocation may have several attempts), which the evidence adapter guarantees |
+| R11 | an action that edits an input, creates an input's object, or deletes an input's object (unless it also deletes the materialized property's own object, whose row is gone) lists the materialized property. An action that deletes the property's own object and also edits or creates an input is still reported, because the edited inputs may belong to other rows; waive it with a reason when they cannot. | none | declaration is complete | same-operation atomicity of the committed effect (one invocation may have several attempts), which the evidence adapter guarantees |
 | R12 | decision tables, all waivable: an action with conditions has a `decision` (`decision_table_missing`, key `<ID>`); a table has `otherwise` (`otherwise_missing`); a row does not use a condition without expression, or one that reaches a derived property without expression (`condition_unspecified`, key `<ID>:<condition id>`) (implementation decision: like the R4 and literal checks, the derived-property part is computed only for conditions whose expression passes the R1 type check); rows with different results have `order` (`row_order_uncited`); for rows `i < j` with different results whose position cites are in one section, the position of `i` comes first (`row_order_mismatch`, key `<ID>:rows.<i>:rows.<j>`, once per pair; implementation decision, since facts carry no order across sections: a row's position cite is in the section of the first listed cite whose quote names its result, and its position is the earliest such quote in that section). A row whose position-cite section is `missing` or `ambiguous` has no position and is not compared. Rows whose position cites are in different sections are not compared, even if they also cite a shared section; ordering across sections relies on `decision.order` and scenarios with overlapping inputs; each row names its result in a cite quote (`result_unsupported`, key `<ID>:rows.<i>` or `<ID>:otherwise`); `next: {unspecified}` is reported (`next_unspecified`); a row `passes(c)` where c may be UNKNOWN, no earlier row is `fails(c)`, and a later row up to the first later `fails(c)` row (inclusive), or `otherwise` when there is no such row, has class `applied` or `pending` (`unsafe_fallthrough`, key `<ID>:rows.<i>`); the body of an `exists` / `none` / `all` may be UNKNOWN (`quantifier_absorbs_unknown`, key `<ID>:<condition id>:<path>` or `derivedProperties.<id>:<path>`, path as in type errors, for example `$.and[1].none`); both see section 9, Static UNKNOWN analysis | `section`, `fieldList` | every row has a source for its result and, within one section, for its place | that rows do not overlap; that the order cite covers the whole table |
 
 ## 6. Rule switches
@@ -146,7 +146,7 @@ The table lists only the optional facts. Every rule may also read the required f
 
 ## 8. Versions
 
-The version is in two places: `v1` in the schema `$id`, and `formatVersion: 1` in the ontology file (R1 fails on any other value). A change that breaks existing ontologies raises both. A change that rejects only files without meaning (for example an empty name) is not a break. Adding the `permission.any_of` form is additive: existing files stay valid, so `formatVersion` stays 1. Adding `parameters` and the parameter and actor reads of the submission criteria (since renamed `conditions`) is additive: existing files stay valid, so `formatVersion` stays 1. Adding `values` on enum parameters is additive; `formatVersion` stays 1.
+The version is in two places: `v1` in the schema `$id`, and `formatVersion: 1` in the ontology file (R1 fails on any other value). A change that breaks existing ontologies raises both. A change that rejects only files without meaning (for example an empty name) is not a break. Adding the `permission.any_of` form is additive: existing files stay valid, so `formatVersion` stays 1. Adding `parameters` and the parameter and actor reads of the submission criteria (since renamed `conditions`) is additive: existing files stay valid, so `formatVersion` stays 1. Adding `values` on enum parameters is additive; `formatVersion` stays 1. Adding `deletes` is additive; `formatVersion` stays 1.
 During 0.x the v1 draft changes in place (`formatVersion` 1, `$id` v1); the rule above applies from the 1.0 semantic freeze.
 
 ## 9. Decision semantics

package/dist/src/checker.js

@@ -261,6 +261,8 @@ export function check(ontology, facts) {
                 v("R1", p, `${f} must be a list`);
         if (c.creates !== undefined && !Array.isArray(c.creates))
             v("R1", p, "creates must be a list");
+        if (c.deletes !== undefined && !Array.isArray(c.deletes))
+            v("R1", p, "deletes must be a list");
         if (!isObj(c.link_effects))
             v("R1", p, "link_effects missing (use {})");
         if (c.crossContext !== undefined) {
@@ -322,6 +324,9 @@ export function check(ontology, facts) {
         for (const o of arr(c.creates))
             if (!objType(o) && !outOfScope.has(o))
                 v("R1", p, `creates ${o}: unknown object`);
+        for (const o of arr(c.deletes))
+            if (!objType(o) && !outOfScope.has(o))
+                v("R1", p, `deletes ${o}: unknown object`);
         for (const e of Object.keys(isObj(c.edit_cites) ? c.edit_cites : {}))
             if (!arr(c.edits).includes(e) || !isObj(c.edit_cites[e]?.cite))
                 v("R1", `${p}.edit_cites.${e}`, "must name an edit and carry a cite");
@@ -633,7 +638,7 @@ export function check(ontology, facts) {
             if (!entities.has(x))
                 v("R5", `entity:${x}`, `outOfScopeObjectTypes.${x} is not a source entity`, "out_of_scope_unknown");
     }
-    const touched = (c) => new Set([...arr(c.edits).map((e) => e.split(".")[0]), ...arr(c.creates)].filter(objType));
+    const touched = (c) => new Set([...arr(c.edits).map((e) => e.split(".")[0]), ...arr(c.creates), ...arr(c.deletes)].filter(objType));
     for (const [cid, c] of Object.entries(commands)) {
         if (!isObj(c))
             continue;
@@ -713,7 +718,7 @@ export function check(ontology, facts) {
     // columns changed on existing rows (per store; checked per object), and the events written
     const observe = (id) => {
         const committed = part(id).committed;
-        const rowStores = new Set(), insertedStores = new Set(), insDelStores = new Set(), events = new Set();
+        const rowStores = new Set(), insertedStores = new Set(), insDelStores = new Set(), deletedStores = new Set(), events = new Set();
         const changedCols = new Map();
         for (const i of committed) {
             for (const e of i.delta.events)
@@ -723,6 +728,8 @@ export function check(ontology, facts) {
                     rowStores.add(tb);
                 if (d.inserted.length)
                     insertedStores.add(tb);
+                if (d.deleted.length)
+                    deletedStores.add(tb);
                 if (d.inserted.length || d.deleted.length)
                     insDelStores.add(tb);
                 for (const u of d.updated)
@@ -730,7 +737,7 @@ export function check(ontology, facts) {
                         changedCols.set(tb, (changedCols.get(tb) ?? new Set()).add(col));
             }
         }
-        return { committed, rowStores, insertedStores, insDelStores, changedCols, events };
+        return { committed, rowStores, insertedStores, insDelStores, deletedStores, changedCols, events };
     };
     for (const [cid, c] of Object.entries(commands)) {
         if (!isObj(c))
@@ -783,14 +790,14 @@ export function check(ontology, facts) {
                 v("R7", cid, "the profile requires evidence, but the action declares none", "evidence_missing");
     if (facts.evidence !== undefined) {
         // a pure link table (not any object's table) may be written when the action declares an `effect` on that link;
-        // an object's table still needs the object in edits / creates
+        // an object's table still needs the object in edits / creates / deletes
         const objTables = new Set(Object.values(objects).map((o) => o?.datasource));
         for (const [cid, c] of Object.entries(commands)) {
             if (!isObj(c) || c.evidence === undefined)
                 continue;
             claimed.add(c.evidence);
             const { rejected } = part(c.evidence);
-            const { committed, rowStores, insertedStores, insDelStores, changedCols, events } = observe(c.evidence);
+            const { committed, rowStores, insertedStores, insDelStores, deletedStores, changedCols, events } = observe(c.evidence);
             const attempts = [...committed, ...rejected].reduce((n, i) => n + i.rolledBackAttempts, 0); // malformed records add nothing
             info.push(`R7 ${cid} (${c.evidence}, ${committed.length} committed, ${rejected.length} rejected invocations, ${attempts} rolled-back attempts): changed {${[...rowStores].sort()}} events {${[...events].sort()}}`);
             if (!committed.length) {
@@ -804,7 +811,7 @@ export function check(ontology, facts) {
             const allowed = new Set([...declared, ...linkTables, ...infra]);
             for (const tb of rowStores)
                 if (!allowed.has(tb))
-                    v("R7", `${cid}:${tb}`, `evidence (${c.evidence}) changed store ${tb}, not declared by edits/creates`, "table_undeclared");
+                    v("R7", `${cid}:${tb}`, `evidence (${c.evidence}) changed store ${tb}, not declared by edits/creates/deletes`, "table_undeclared");
             for (const e of events)
                 if (!arr(c.emits).includes(e))
                     v("R7", `${cid}:event:${e}`, `evidence (${c.evidence}) wrote event ${e}, not in emits`, "event_undeclared");
@@ -831,6 +838,9 @@ export function check(ontology, facts) {
             for (const o of arr(c.creates))
                 if (objType(o) && !insertedStores.has(objects[o].datasource))
                     unwitnessed(`creates:${o}`, `inserted a row into ${objects[o].datasource}`);
+            for (const o of arr(c.deletes))
+                if (objType(o) && !deletedStores.has(objects[o].datasource))
+                    unwitnessed(`deletes:${o}`, `deleted a row of ${objects[o].datasource}`);
             for (const l of links.filter(pureLink))
                 if (!insDelStores.has(l.table))
                     unwitnessed(`link:${l.id}`, `inserted or deleted a row of the link store ${l.table}`);
@@ -967,7 +977,9 @@ export function check(ontology, facts) {
             for (const [cid, c] of Object.entries(commands)) {
                 if (!isObj(c))
                     continue;
-                const hit = reads.filter((r) => arr(c.edits).includes(r) || arr(c.creates).includes(r.split(".")[0]));
+                // deleting an input object writes it, unless the target's own object is deleted too (the target row is gone)
+                const hit = reads.filter((r) => arr(c.edits).includes(r) || arr(c.creates).includes(r.split(".")[0])
+                    || (arr(c.deletes).includes(r.split(".")[0]) && !arr(c.deletes).includes(name)));
                 if (hit.length && !arr(c.edits).includes(target))
                     v("R11", `${cid}:${target}`, `${cid} writes ${hit.join(", ")} (inputs of ${target}) but does not list ${target} in edits`, "materialization_missing");
             }

package/dist/src/query.d.ts

@@ -162,6 +162,7 @@ export type QueryAction = {
         cite: QueryCite | null;
     }[];
     creates: string[];
+    deletes: string[];
     emits: string[];
     linkEffects: {
         link: string;
@@ -232,6 +233,7 @@ export type QueryObject = {
         action: string;
         edits: string[];
         creates: boolean;
+        deletes: boolean;
     }[];
     readers: {
         action: string;
@@ -261,6 +263,7 @@ export type QueryWrites = {
         path: string[];
     }[];
     creators: string[];
+    deleters: string[];
 };
 export type QueryReads = {
     target: string;

package/dist/src/query.js

@@ -344,6 +344,7 @@ export function queryAction(ont, id) {
         decision: isObj(a.decision) ? { order: citeOf(map(a.decision.order).cite), rows: decisionRows(an, id, a) } : null,
         edits: strs(a.edits).map((prop) => ({ prop, cite: citeOf(map(own(editCites, prop)).cite) })),
         creates: strs(a.creates),
+        deletes: strs(a.deletes),
         emits: strs(a.emits),
         linkEffects: Object.entries(map(a.link_effects)).flatMap(([link, le]) => {
             const e = map(le);
@@ -396,8 +397,9 @@ export function queryObject(ont, id) {
     for (const [aid, a] of sortedActions(ont)) {
         const edits = strs(a.edits).filter((e) => e.startsWith(prefix));
         const creates = strs(a.creates).includes(id);
-        if (edits.length || creates)
-            writers.push({ action: aid, edits, creates });
+        const deletes = strs(a.deletes).includes(id);
+        if (edits.length || creates || deletes)
+            writers.push({ action: aid, edits, creates, deletes });
     }
     if (o === undefined)
         return { id, context: null, datasource: null, doc: null, outOfScope, scope: null, properties: [], derived: [], stateMachine: null, links: [], writers, readers: [], unanalyzed: [] };
@@ -494,7 +496,8 @@ export function queryWrites(ont, t) {
     const acts = sortedActions(ont);
     const writersOf = (prop, path) => acts.filter(([, a]) => strs(a.edits).includes(prop)).map(([aid, a]) => ({ action: aid, cite: citeOf(map(own(map(a.edit_cites), prop)).cite), path }));
     if (tg.kind === "property")
-        return { target: t, kind: "property", unanalyzed: [], writers: writersOf(t, []), creators: acts.filter(([, a]) => strs(a.creates).includes(tg.obj)).map(([aid]) => aid) };
+        return { target: t, kind: "property", unanalyzed: [], writers: writersOf(t, []), creators: acts.filter(([, a]) => strs(a.creates).includes(tg.obj)).map(([aid]) => aid),
+            deleters: acts.filter(([, a]) => strs(a.deletes).includes(tg.obj)).map(([aid]) => aid) };
     // Breadth first from the derived target: each input once, by its shortest path.
     const an = new Analysis(ont);
     const writers = [];
@@ -518,7 +521,7 @@ export function queryWrites(ont, t) {
         frontier = next;
     }
     writers.sort((a, b) => a.path.length - b.path.length || sortStr(a.path.join(), b.path.join()) || sortStr(a.action, b.action));
-    return { target: t, kind: "derived", unanalyzed: derivedErrors(an, seenDerived), writers, creators: [] };
+    return { target: t, kind: "derived", unanalyzed: derivedErrors(an, seenDerived), writers, creators: [], deleters: [] };
 }
 export function queryReads(ont, t) {
     const tg = target(ont, t);

package/ontology.schema.json

@@ -689,6 +689,13 @@
           },
           "description": "Objects the action creates (optional). Foundation (closest analog: the create-object rules of a Palantir action type). R1: each must be a key of `objectTypes` or of `outOfScopeObjectTypes`. Declared objects here are touched (R5, R6, R7) and count as writing every property of that object for R11. R5: creating the `from` object of a link with `create_rule` triggers that rule."
         },
+        "deletes": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Objects whose rows the action removes (optional). Foundation (closest analog: the delete-object rules of a Palantir action type). R1: each must be a key of `objectTypes` or of `outOfScopeObjectTypes`. A soft delete is an `edits` of the marker property. Declared objects here are touched (R5, R6, R7). R7: for an action with `evidence`, each declared object here must have a row of its datasource deleted by at least one committed invocation (else `effect_unwitnessed`, key `<ID>:deletes:<Object>`); an upsert declares `creates`, not `deletes`. R11: deleting an input of a `materializedFrom` property counts as writing it, unless the object of that property is also listed here."
+        },
         "edit_cites": {
           "type": "object",
           "propertyNames": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githonllc/avouch",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -30,6 +30,7 @@
     "dist/src/",
     "dist/cli/",
     "ontology.schema.json",
+    "vocab.ttl",
     "SPEC.md",
     "docs/",
     "NOTICE"

package/vocab.ttl

@@ -0,0 +1,499 @@
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix ofv: <https://w3id.org/avouch/v1/vocab#> .
+
+<https://w3id.org/avouch/v1/vocab> a owl:Ontology ;
+  rdfs:label "Avouch vocabulary"@en ;
+  rdfs:seeAlso <https://w3id.org/avouch/v1/schema.json> .
+
+ofv:Context a rdfs:Class ;
+  rdfs:label "Context" ;
+  rdfs:comment "Exported from the YAML path contexts.<name>." ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:OutOfScopeObjectType a rdfs:Class ;
+  rdfs:label "OutOfScopeObjectType" ;
+  rdfs:comment "Exported from the YAML path outOfScopeObjectTypes.<name>." ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:DerivedProperty a rdfs:Class ;
+  rdfs:label "DerivedProperty" ;
+  rdfs:comment "Exported from the YAML path derivedProperties.<id>." ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:ActionType a rdfs:Class ;
+  rdfs:label "ActionType" ;
+  rdfs:comment "Exported from the YAML path actionTypes.<ID>." ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:index a rdf:Property ;
+  rdfs:label "index" ;
+  rdfs:comment "Position (from 0) of a record in its YAML list. YAML: conditions[], decision.rows[], transitions[], knownSourceGaps[], permission_rows_not_commands[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:key a rdf:Property ;
+  rdfs:label "key" ;
+  rdfs:comment "Name of an entry in a YAML mapping. YAML: non_link_fields.<key>, edit_cites.<key>, link_effects.<key>, transitions[].bind.<key>" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:name a rdf:Property ;
+  rdfs:label "name" ;
+  rdfs:comment "Name of a permission row that is not a command. YAML: permission_rows_not_commands[].name" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:reason a rdf:Property ;
+  rdfs:label "reason" ;
+  rdfs:comment "Reason text. YAML: permission_rows_not_commands[].reason, outOfScopeObjectTypes.<name>, objectTypes.<name>.non_link_fields.<key>.reason" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:cite a rdf:Property ;
+  rdfs:label "cite" ;
+  rdfs:comment "Source citation (a node with doc and quote). YAML: cite, in any record that has one, scope.cite, scope.global[].cite, scope.root.cite, dispositions.<ID>.cite, decision.order.cite, decision…next.cite, derivedProperties.<id>.cite, ….principals.cite, actionTypes.<ID>.idempotencyKey.cite" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:doc a rdf:Property ;
+  rdfs:label "doc" ;
+  rdfs:comment "Source document reference. YAML: doc, in any record that has one; also cite.doc" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:quote a rdf:Property ;
+  rdfs:label "quote" ;
+  rdfs:comment "Quoted source text. YAML: cite.quote" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:id a rdf:Property ;
+  rdfs:label "id" ;
+  rdfs:comment "Identifier of a record. YAML: knownSourceGaps[].id, actionTypes.<ID>.conditions[].id" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:rule a rdf:Property ;
+  rdfs:label "rule" ;
+  rdfs:comment "Rule code of a source gap. YAML: knownSourceGaps[].rule" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:kind a rdf:Property ;
+  rdfs:label "kind" ;
+  rdfs:comment "Kind of a source gap. YAML: knownSourceGaps[].kind" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:keys a rdf:Property ;
+  rdfs:label "keys" ;
+  rdfs:comment "Keys of a record (permission keys, or gap keys). YAML: knownSourceGaps[].keys, actionTypes.<ID>.permission.keys" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:doc_line a rdf:Property ;
+  rdfs:label "doc_line" ;
+  rdfs:comment "Document line of a source gap. YAML: knownSourceGaps[].doc_line" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:conflict a rdf:Property ;
+  rdfs:label "conflict" ;
+  rdfs:comment "Conflict text of a source gap. YAML: knownSourceGaps[].conflict" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:proposed a rdf:Property ;
+  rdfs:label "proposed" ;
+  rdfs:comment "Proposed fix of a source gap. YAML: knownSourceGaps[].proposed" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:description a rdf:Property ;
+  rdfs:label "description" ;
+  rdfs:comment "Label of a context: a literal substring of the source line that lists its objects. YAML: contexts.<name>" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:infrastructureStores a rdf:Property ;
+  rdfs:label "infrastructureStores" ;
+  rdfs:comment "Infrastructure stores that are not object types. YAML: infrastructureStores[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:permission_rows_not_commands a rdf:Property ;
+  rdfs:label "permission_rows_not_commands" ;
+  rdfs:comment "Permission rows that are not commands. YAML: permission_rows_not_commands[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:knownSourceGaps a rdf:Property ;
+  rdfs:label "knownSourceGaps" ;
+  rdfs:comment "Known gaps in the source document. YAML: knownSourceGaps[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:context a rdf:Property ;
+  rdfs:label "context" ;
+  rdfs:comment "Context of an object type, action type or create rule. YAML: objectTypes.<name>.context, actionTypes.<ID>.context, linkTypes[].create_rule.context" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:datasource a rdf:Property ;
+  rdfs:label "datasource" ;
+  rdfs:comment "Store that holds the object. YAML: objectTypes.<name>.datasource" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:non_link_fields a rdf:Property ;
+  rdfs:label "non_link_fields" ;
+  rdfs:comment "Fields that look like links but are not. YAML: objectTypes.<name>.non_link_fields" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:stateMachines a rdf:Property ;
+  rdfs:label "stateMachines" ;
+  rdfs:comment "State machine of an object type. YAML: stateMachines.<name>" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:initial a rdf:Property ;
+  rdfs:label "initial" ;
+  rdfs:comment "Initial state. YAML: stateMachines.<name>.initial" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:terminal a rdf:Property ;
+  rdfs:label "terminal" ;
+  rdfs:comment "Terminal state. YAML: stateMachines.<name>.terminal[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:transitions a rdf:Property ;
+  rdfs:label "transitions" ;
+  rdfs:comment "State transition. YAML: stateMachines.<name>.transitions[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:from a rdf:Property ;
+  rdfs:label "from" ;
+  rdfs:comment "Source state of a transition. YAML: stateMachines.<name>.transitions[].from" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:to a rdf:Property ;
+  rdfs:label "to" ;
+  rdfs:comment "Target state of a transition. YAML: stateMachines.<name>.transitions[].to" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:by a rdf:Property ;
+  rdfs:label "by" ;
+  rdfs:comment "Action type that causes a transition. YAML: stateMachines.<name>.transitions[].by[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:out_of_scope a rdf:Property ;
+  rdfs:label "out_of_scope" ;
+  rdfs:comment "Why no declared action performs the transition. YAML: stateMachines.<name>.transitions[].out_of_scope" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:bind a rdf:Property ;
+  rdfs:label "bind" ;
+  rdfs:comment "Per-action evidence for a transition, keyed by action id. YAML: stateMachines.<name>.transitions[].bind.<ID>" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:class a rdf:Property ;
+  rdfs:label "class" ;
+  rdfs:comment "State class of a property: canonical, derived, policy or unknown. YAML: objectTypes.<name>.properties.<p>.class" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:canonical_values a rdf:Property ;
+  rdfs:label "canonical_values" ;
+  rdfs:comment "Values of a non-canonical property that the source explicitly marks as canonical. YAML: objectTypes.<name>.properties.<p>.canonical_values" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:values a rdf:Property ;
+  rdfs:label "values" ;
+  rdfs:comment "Values of a list. YAML: canonical_values.values[], conditions[].reads[].values[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:materializedFrom a rdf:Property ;
+  rdfs:label "materializedFrom" ;
+  rdfs:comment "The source requires this derived property to be stored in the same operation as its inputs. YAML: objectTypes.<name>.properties.<p>.materializedFrom" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:reads a rdf:Property ;
+  rdfs:label "reads" ;
+  rdfs:comment "Properties read. YAML: materializedFrom.reads[], derivedProperties.<id>.reads[], conditions[].reads[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:cites a rdf:Property ;
+  rdfs:label "cites" ;
+  rdfs:comment "Citations, each a node with ofv:cite. YAML: objectTypes.<name>.properties.<p>.materializedFrom.cites[], actionTypes.<ID>.conditions[].cites[], decision.rows[].cites[], decision.otherwise.cites[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:cardinality a rdf:Property ;
+  rdfs:label "cardinality" ;
+  rdfs:comment "Cardinality text of a link type, kept as written. YAML: linkTypes[].cardinality" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:via a rdf:Property ;
+  rdfs:label "via" ;
+  rdfs:comment "Foreign-key field on the from object or the link store name (linkTypes[].via); the mechanism of a cross-context write (crossContext.via). YAML: linkTypes[].via, actionTypes.<ID>.crossContext.via" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:table a rdf:Property ;
+  rdfs:label "table" ;
+  rdfs:comment "The link's own store. YAML: linkTypes[].table" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:create_rule a rdf:Property ;
+  rdfs:label "create_rule" ;
+  rdfs:comment "Who may establish the link. YAML: linkTypes[].create_rule" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:with_creates a rdf:Property ;
+  rdfs:label "with_creates" ;
+  rdfs:comment "Objects the action must create in the same operation. YAML: linkTypes[].create_rule.with_creates[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:exceptions a rdf:Property ;
+  rdfs:label "exceptions" ;
+  rdfs:comment "Exceptions to a create rule. YAML: linkTypes[].create_rule.exceptions" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:commands a rdf:Property ;
+  rdfs:label "commands" ;
+  rdfs:comment "Action types that are exceptions to a create rule. YAML: linkTypes[].create_rule.exceptions.commands[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:of a rdf:Property ;
+  rdfs:label "of" ;
+  rdfs:comment "Object a derived property is defined on. YAML: derivedProperties.<id>.of" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:doc_term a rdf:Property ;
+  rdfs:label "doc_term" ;
+  rdfs:comment "Term used in the source document. YAML: derivedProperties.<id>.doc_term, actionTypes.<ID>.doc_term" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:evidence a rdf:Property ;
+  rdfs:label "evidence" ;
+  rdfs:comment "Id of the evidence that implements the action. YAML: actionTypes.<ID>.evidence" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:emits a rdf:Property ;
+  rdfs:label "emits" ;
+  rdfs:comment "Event types the action writes. YAML: actionTypes.<ID>.emits[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:creates a rdf:Property ;
+  rdfs:label "creates" ;
+  rdfs:comment "Object types an action type creates. YAML: actionTypes.<ID>.creates[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:deletes a rdf:Property ;
+  rdfs:label "deletes" ;
+  rdfs:comment "Object types whose rows an action type removes (a soft delete is an edits). YAML: actionTypes.<ID>.deletes[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:edits a rdf:Property ;
+  rdfs:label "edits" ;
+  rdfs:comment "Properties an action type edits. YAML: actionTypes.<ID>.edits[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:edit_cites a rdf:Property ;
+  rdfs:label "edit_cites" ;
+  rdfs:comment "Citations of edits. YAML: actionTypes.<ID>.edit_cites.<key>" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:crossContext a rdf:Property ;
+  rdfs:label "crossContext" ;
+  rdfs:comment "Cross-context write of an action type. YAML: actionTypes.<ID>.crossContext" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:permission a rdf:Property ;
+  rdfs:label "permission" ;
+  rdfs:comment "Permission of an action type: a string, or a node with keys. YAML: actionTypes.<ID>.permission" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:conditional_keys a rdf:Property ;
+  rdfs:label "conditional_keys" ;
+  rdfs:comment "Permission keys needed only under a condition. YAML: actionTypes.<ID>.permission.conditional_keys[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:none a rdf:Property ;
+  rdfs:label "none" ;
+  rdfs:comment "Why there is no key (permission), or why the link is not changed (link effect). YAML: actionTypes.<ID>.permission.none, actionTypes.<ID>.link_effects.<key>.none" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:conditional_cite a rdf:Property ;
+  rdfs:label "conditional_cite" ;
+  rdfs:comment "Citation for the conditional keys. YAML: actionTypes.<ID>.permission.conditional_cite" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:any_of a rdf:Property ;
+  rdfs:label "any_of" ;
+  rdfs:comment "At least 2 alternatives, each a keys form; the actor may run the action when its keys satisfy any one of them (OR). YAML: actionTypes.<ID>.permission.any_of" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:parameters a rdf:Property ;
+  rdfs:label "parameters" ;
+  rdfs:comment "Parameters of an action type, the inputs it takes; each has a key and a cite. YAML: actionTypes.<ID>.parameters" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:param a rdf:Property ;
+  rdfs:label "param" ;
+  rdfs:comment "Parameter named in a read, optionally with values. YAML: actionTypes.<ID>.conditions[].reads[].param" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:actor a rdf:Property ;
+  rdfs:label "actor" ;
+  rdfs:comment "The caller read by a criterion: id or keys. YAML: actionTypes.<ID>.conditions[].reads[].actor" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:submissionCriteria a rdf:Property ;
+  rdfs:label "submissionCriteria" ;
+  rdfs:comment "Renamed to conditions; exports no longer use it. YAML before the rename: actionTypes.<ID>.submissionCriteria[]" ;
+  owl:deprecated true ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:conditions a rdf:Property ;
+  rdfs:label "conditions" ;
+  rdfs:comment "Condition of an action type: a named claim, written as an expression or stated as not yet written. YAML: actionTypes.<ID>.conditions[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:expr a rdf:Property ;
+  rdfs:label "expr" ;
+  rdfs:comment "Expression as one rdf:JSON literal (object keys sorted, no white space), not as triples. YAML: actionTypes.<ID>.conditions[].expr, derivedProperties.<id>.expr" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:prop a rdf:Property ;
+  rdfs:label "prop" ;
+  rdfs:comment "Property named in a read with values. YAML: actionTypes.<ID>.conditions[].reads[].prop" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:reads_unspecified a rdf:Property ;
+  rdfs:label "reads_unspecified" ;
+  rdfs:comment "Statement that the reads are not specified. YAML: actionTypes.<ID>.conditions[].reads_unspecified" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:scenarios a rdf:Property ;
+  rdfs:label "scenarios" ;
+  rdfs:comment "Scenario ids. YAML: conditions[].scenarios[], link_effects.<key>.scenarios[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:link_effects a rdf:Property ;
+  rdfs:label "link_effects" ;
+  rdfs:comment "Effect of an action type on a link type. YAML: actionTypes.<ID>.link_effects" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:effect a rdf:Property ;
+  rdfs:label "effect" ;
+  rdfs:comment "Text of a link effect. YAML: actionTypes.<ID>.link_effects.<key>.effect" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:unspecified a rdf:Property ;
+  rdfs:label "unspecified" ;
+  rdfs:comment "Statement that something is not specified. YAML: actionTypes.<ID>.link_effects.<key>.unspecified, actionTypes.<ID>.crossContext.unspecified, actionTypes.<ID>.conditions[].unspecified, decision.rows[].next.unspecified, decision.otherwise.next.unspecified" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:Disposition a rdfs:Class ;
+  rdfs:label "Disposition" ;
+  rdfs:comment "A result that a decision table can give. Exported from the YAML path dispositions.<ID>." ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:dispositionClass a rdf:Property ;
+  rdfs:label "dispositionClass" ;
+  rdfs:comment "Class of a disposition: rejected, recorded, pending or applied. YAML: dispositions.<ID>.class" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:decision a rdf:Property ;
+  rdfs:label "decision" ;
+  rdfs:comment "Decision table of an action type. YAML: actionTypes.<ID>.decision" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:hitPolicy a rdf:Property ;
+  rdfs:label "hitPolicy" ;
+  rdfs:comment "Hit policy of a decision table; v1 has only first (top to bottom, first match). YAML: actionTypes.<ID>.decision.hitPolicy" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:order a rdf:Property ;
+  rdfs:label "order" ;
+  rdfs:comment "Citation for the row order of a decision table. YAML: actionTypes.<ID>.decision.order" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:rows a rdf:Property ;
+  rdfs:label "rows" ;
+  rdfs:comment "Row of a decision table, with ofv:index. YAML: actionTypes.<ID>.decision.rows[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:when a rdf:Property ;
+  rdfs:label "when" ;
+  rdfs:comment "Test of a row: a node with ofv:passes or ofv:fails. YAML: actionTypes.<ID>.decision.rows[].when" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:passes a rdf:Property ;
+  rdfs:label "passes" ;
+  rdfs:comment "Id of a condition that must evaluate to T. YAML: actionTypes.<ID>.decision.rows[].when.passes" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:fails a rdf:Property ;
+  rdfs:label "fails" ;
+  rdfs:comment "Id of a condition that does not evaluate to T (it is F or U). It is not a negation. YAML: actionTypes.<ID>.decision.rows[].when.fails" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:result a rdf:Property ;
+  rdfs:label "result" ;
+  rdfs:comment "Disposition that a row gives: an ofv:Disposition, or a literal when the id is not declared. YAML: actionTypes.<ID>.decision.rows[].result, actionTypes.<ID>.decision.otherwise.result" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:otherwise a rdf:Property ;
+  rdfs:label "otherwise" ;
+  rdfs:comment "Last row of a decision table; it gives the result when no row matches. YAML: actionTypes.<ID>.decision.otherwise" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:next a rdf:Property ;
+  rdfs:label "next" ;
+  rdfs:comment "What follows a pending result. YAML: actionTypes.<ID>.decision.rows[].next, actionTypes.<ID>.decision.otherwise.next" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:actions a rdf:Property ;
+  rdfs:label "actions" ;
+  rdfs:comment "Action type of this system that follows. YAML: decision.rows[].next.actions[], decision.otherwise.next.actions[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:external a rdf:Property ;
+  rdfs:label "external" ;
+  rdfs:comment "Step outside this system that follows. YAML: decision.rows[].next.external, decision.otherwise.next.external" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:scope a rdf:Property ;
+  rdfs:label "scope" ;
+  rdfs:comment "Tenant scope of the ontology. YAML: scope" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:scopeBy a rdf:Property ;
+  rdfs:label "scopeBy" ;
+  rdfs:comment "Name of the field that holds the tenant. YAML: scope.by" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:global a rdf:Property ;
+  rdfs:label "global" ;
+  rdfs:comment "Object type that all tenants share, with its citation. YAML: scope.global[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:root a rdf:Property ;
+  rdfs:label "root" ;
+  rdfs:comment "Object type that is the tenant itself, with its citation. YAML: scope.root" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:type a rdf:Property ;
+  rdfs:label "type" ;
+  rdfs:comment "A type. For a value type: a literal (enum, timestamp, duration, date, timezone, id, integer or boolean), the class whose ids the value holds, or a node with ofv:set. For a scope entry: the class of the entry. YAML: objectTypes.<name>.properties.<p>.type, actionTypes.<ID>.parameters.<n>.type, derivedProperties.<id>.type, scope.global[].type, scope.root.type" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:set a rdf:Property ;
+  rdfs:label "set" ;
+  rdfs:comment "Element type of a set type, written as for ofv:type; string is allowed here only. YAML: ….type.set" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:optional a rdf:Property ;
+  rdfs:label "optional" ;
+  rdfs:comment "The caller may leave the parameter out; it is then null. YAML: actionTypes.<ID>.parameters.<n>.optional" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:principals a rdf:Property ;
+  rdfs:label "principals" ;
+  rdfs:comment "Actor kinds that one permission alternative admits, with its own citation; an actor of another kind is denied. YAML: actionTypes.<ID>.permission.principals, actionTypes.<ID>.permission.any_of[].principals" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:kinds a rdf:Property ;
+  rdfs:label "kinds" ;
+  rdfs:comment "One actor kind. YAML: actionTypes.<ID>.permission.principals.kinds[], actionTypes.<ID>.permission.any_of[].principals.kinds[]" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:idempotencyKey a rdf:Property ;
+  rdfs:label "idempotencyKey" ;
+  rdfs:comment "Declaration of whether the caller must supply an idempotency key for this action type, with its citation. Absent means unspecified, not false; never derived from the action's effects. YAML: actionTypes.<ID>.idempotencyKey" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .
+
+ofv:required a rdf:Property ;
+  rdfs:label "required" ;
+  rdfs:comment "Whether the caller must supply an idempotency key; true and false are both explicit, cited claims. YAML: actionTypes.<ID>.idempotencyKey.required" ;
+  rdfs:isDefinedBy <https://w3id.org/avouch/v1/vocab> .