The JSON schema every rulework must conform to: its fields, operations and vocabulary, and how versioned schema URLs work.
The law format is defined by a JSON Schema. Every rulework in the corpus must conform to this schema.
Everything below the version history is generated from the released schema itself, so this page and the contract cannot disagree. Where a field has a concept page, the table links to it.
This page owns the field-level detail, down to which operands each operation takes. How a rulework is put together, and why, is walked through on one real article in Law Format.
The current schema version is v0.8.21.
Schema URLs use immutable git tags to guarantee reproducibility. The format is:
The tag schema-vX.Y.Z is created when a schema version is released. Using tags instead of refs/heads/main ensures that the schema a version of a rulework references can never change underneath it. See RFC-013 for the rationale.
This table is the single source of truth for which schema version introduced which construct. RFCs that add a construct reference this table rather than asserting a version independently.
| Version | Introduces | RFC |
|---|---|---|
| v0.8.21 | FOREACH takes combine: DISTINCT: the unique results as an array, in the order each first occurs. Two results are the same when EQUALS says so: scalars by value, rows field by field, lists element by element in order. null stays once, and an empty collection gives an empty array. To get the value that several equal results share, apply ONLY to the result of DISTINCT; ONLY stays strict. A file on v0.8.20 or earlier that uses DISTINCT is refused | RFC-016 |
| v0.8.20 | A property of the state of a projection may be an array with its columns, each a name and a scalar type (boolean, number, string, amount or date), so it holds a table; in the state an array always declares its columns. It starts as an empty list and is never null. A step replaces the array whole with a bare reference, such as $record.<field> for an array of rows a fact holds; a row lacking a column holds null there, and a row with a column the array does not declare, or with a value that is not of its column’s type, fails the step. A parameter of type array may declare its columns too (arrayColumn), and the loader holds an array in the state to the columns of the fact field or state property it is filled from, where that source declares them. A read model reads the array as a field of the row of its aggregate and iterates over it with a nested FOREACH. A property of the state may also declare nullable: true: a boolean, number or amount then starts as null and a step may set it to null, while a string or a date may hold null as before and an array never does. The loader refuses a step that fills a property that is not nullable from a source that may be null. A file on v0.8.19 or earlier keeps loading as it did, and one that has an array with columns or nullable in its state is refused | none yet, an experiment |
| v0.8.19 | Each article of a REDUCTIE with a machine_readable takes one of two forms: an aggregate, a projection with per and no execution, or a read model, an execution that reads aggregates (source.projections). One file may hold both; an article that is neither, or both, is refused. source.projections names the article of the aggregate, <regulation>#<article>, also in the reading file itself; the reduction alone is refused, and so is a reference to an article that does not exist or plays no aggregate. A reduction reads recorded facts only through an aggregate: source.facts is gone, and an aggregate per fact names the article that requires it in per, with the fact’s name where the article requires more than one (v0.8.18). An article of a reduction that only calls other rulework reads no chronicle and is refused; such a rule belongs in policy. A step of a projection with per reads $record.id, the id of its own record, as it reads $record.refers_to since v0.8.17; under v0.8.18 and earlier $record.id still reads a field of the record named id. A file on v0.8.18 or earlier keeps loading as it did, source.facts, a reference to the reduction alone and a reduction without aggregates included, so such a file is not valid under v0.8.19 unchanged | none yet, an experiment |
| v0.8.18 | The third segment of projection.per and of steps[].record may be the name of a fact the article requires, in lower case: <regulation>#<article>#<fact> addresses the executograms of that fact alone, and $record in such a step reads the fields of that fact. An article that requires more than one fact can now have a step per fact, each by its name; a step without a name, or with #EXECUTOGRAM, on such an article is still refused. #<KIND> keeps working as before. The loader refuses a fact name the article does not require, and refuses it in a file on v0.8.17 or earlier. From v0.8.18 the loader also holds per to the article it names, as it holds a step. per names a kind the article gives or a fact it requires. Without either, the article gives one kind of record and requires at most one fact. A file that declares v0.8.17 loads as before; moved to v0.8.18, its per must meet these rules | none yet, an experiment |
| v0.8.17 | A projection plays one aggregate per record of a kind: projection.per names the article the root rests on (<regulation>#<article>, with #<KIND> where the article gives more than one kind). An aggregate is the root and the records that refer to it through refers_to, transitively; another record of the root’s kind that refers in is an aggregate of its own and counts there for its effects only. Such a projection answers no question of its own and has no execution. Another reduction reads it with source.projections, by the $id of that reduction: one row per root the chronicle holds on the calculation date, the last state of its aggregate with the root’s id, and with where only the roots that hold the value of a parameter under a name. A reduction reads no decisions any more (source.decisions): a row about a decision comes from an aggregate. key is gone, and a step passes no parameter of the question ($<name>): its parameters are $record.<field> and $state.<property>, so a fold depends on the chronicle alone. A step of a projection with per reads $record.refers_to, the id of the record its record refers to, or null. refers_to names, on every record, the record this record is about, so any fact may refer to an earlier record of the chronicle, with or without effects, and a decision taken on no submission refers to the decision it affects. A decision revokes only a record it is about: one its refers_to reaches, directly or through the records it refers to in turn; the cell and the engine refuse another. A file on v0.8.16 or earlier keeps loading as it did, key, question parameters and source.decisions included, so such a file that uses one of them is not valid under v0.8.17 unchanged | none yet, an experiment |
| v0.8.16 | A step of a projection is held to three stricter rules: the article it is on must give a record, $record reads only the fields of the kind of record the step is about, and the step passes every required parameter that the output it takes reads, directly or through another output of its article. The loader checks the steps when the reduction loads, against the newest version it holds of each law they name, and the engine again when it plays the projection. A reduction on v0.8.15 or earlier still loads under the old rules and is checked only when it plays, so a v0.8.15 file that breaks one of the new rules is not valid under v0.8.16 unchanged. One rule is looser in every version: a step may take an output of an article that has an input or an open term, as long as that output does not read them, directly or through another output of its article | none yet, an experiment |
| v0.8.15 | A fact an article requires may have effects, as a decision has them: requires[].effects with revokes: refers_to, so a fact revokes the record it refers to, and optionally when, a boolean parameter the fact holds. The receipt of a copy of a ruling that annuls a decision (Awb 8:72 lid 1, 8:79) revokes the decision it refers to this way; a fact with effects may also refer to another earlier record of the chronicle. An effect of a decision may name any earlier record, a fact too. revokes means the record does not count, from the start (ex tunc). A change from a later day on, such as a suspension (Awb 8:81) or a withdrawal with effect from a date, is no effect but a step of the reduction that puts the dates in its state. From v0.8.15 the parameter a decision’s effect revokes must be a string or a decision (which counts by its id) and may not be nullable; a file on v0.8.14 still loads. A file valid under v0.8.14 is valid under v0.8.15 unchanged | none yet, an experiment |
| v0.8.14 | A decision in the list form of produces may name its effects on another decision: revokes, naming a parameter of the article whose value is that decision (Awb 7:11 lid 2). With when, an effect holds only if a boolean output of the decision is true, so a decision on an objection revokes only when the objection is well-founded. A decision in the place of another revokes it and counts itself. A REDUCTIE may have a projection: a state of named properties with a type, each starting from the value of its type, and per article a record rests on (with #<KIND> where the article gives more than one kind), a step that takes outputs of a law as an article does (input with source.regulation, parameters from $record.<field> or $state.<property>) and gives properties their values with actions, as an article does: output names a property, value is a bare reference ($<input>, $record.<field> or $state.<property>). The law runs in the version in force on the day of the record and reads no input and no open term. The engine plays a cell’s chronicle forward through it and answers from the last state with the reduction’s execution. A record counts unless a later record that itself counts revokes it, so a revoked record revokes nothing and what it alone revoked counts again; only the records that count change the state. when reads only an output of the same decision. A step may pass a parameter of the question to the law it calls. Revoking takes a record out of the whole history (ex tunc); a change from a later day on is a step with a date property. One version of the reduction, the one in force on the calculation date, plays the whole chronicle, and records recorded after that date are not played. With key, a projection plays only the records of one person: those that hold the value asked for under the key’s name, and the records that refer to them. A record that refers in with another key of its own counts for its effects only: what it revokes is revoked here too, but its step is not applied. It records which record set each property last, and per record whether it was applied, revoked or counts for its effects only, in the result and as a PROJECTION node of the trace. Experimental; a cell plays a projection when a policy takes its answer through source.reduction, and LawExecutionService::evaluate_projection plays one directly. A file valid under v0.8.13 is valid under v0.8.14 unchanged | none yet, an experiment |
| v0.8.13 | combine on an open term (v0.8.8) and in a source beside reduction (v0.8.9) are gone. The engine asks one cell for a question and merges no answers; more than one cell of the call that a term names is an error at run time. How one question would reach several cells of a category is an open question. A file that uses neither is valid under v0.8.13 unchanged | RFC-048 |
| v0.8.12 | The article a decision value was taken under is basis (was grondslag), in the value, in the rows of source.decisions and source.facts, and in $besluit.basis. A REDUCTIE names no competent_authority: it sits with its cell (corpus/cells/<cell>/reductions/), or with none (corpus/cells/reductions/), and the directory says whose it is. | RFC-048 |
| v0.8.11 | source.decisions may name its article by a $-reference to a parameter of the reading article, so a reduction about decisions under another law can be given the article to search for. It reads the chronicle of the cell that runs it, one article per input. The description gives the rows: fields, findings and outputs under their own names, with grondslag and id; a decision value in a row is a row with the id of the record that holds it and every output its article declares, null where the value has none. The rows of source.facts also carry grondslag and refers_to. A file valid under v0.8.10 is valid under v0.8.11 unchanged | RFC-048 |
| v0.8.10 | BEROEP as a kind of submission, next to AANVRAAG and BEZWAAR, and UITSPRAAK as a legal character: in produces.submission.kind and produces.legal_character, as the type of a list item, and in a hook’s applies_to. Awb 8:70 establishes the appeal and decides on it; the judgment of the court is not a besluit (Awb 1:1 lid 2 onder c). A file valid under v0.8.9 is valid under v0.8.10 unchanged | RFC-053 |
| v0.8.9 | A REDUCTIE is a named answer of its cell and fills no open term: implements on it is refused again. An article of UITVOERINGSBELEID binds an open term to such an answer, with implements and an input source: {reduction: <answer>, parameters, combine?}; the policy then names its holder by name in a root competent_authority, a property the schema now describes. Only a REDUCTIE reads a chronicle (source.decisions, source.facts). A REDUCTIE with implements stays valid only under a $schema of v0.8.5 to v0.8.8 | RFC-048 |
| v0.8.8 | An open term and a required fact (requires with fact) may carry their own competent_authority, one named authority or a list: who may answer the term, who establishes the fact. combine on an open term makes one value of the answers of several competent answerers, with the aggregations of FOREACH. An engine that routes on competence (RFC-052) asks, for an open term of an article read through source.regulation, only the answerers the term names. On the article the field still names who decides. A file valid under v0.8.7 is valid under v0.8.8 unchanged | RFC-052 |
| v0.8.7 | A requires entry may name a fact the article requires to exist (fact), with the article’s parameters it holds and a description; such an entry names no other provision. source.facts (<regulation>#<article>#<fact>) replaces source.executograms: a REDUCTIE reads the recorded instances of that fact. Not additive: a reduction that named a stream under v0.8.6 names the fact under v0.8.7 | RFC-051 |
| v0.8.6 | A REDUCTIE may read the executograms of a stream of its cell (source.executograms), as it reads decisions; combine: ONLY gives the one result a FOREACH filter leaves, null when it leaves none and an error when it leaves more. A file valid under v0.8.5 is valid under v0.8.6 unchanged | RFC-051 |
| v0.8.5 | A REDUCTIE may fill an open term with implements: the engine runs it for that term like any implementation, also in a nested call. It still has no hooks, overrides, execution.produces or open_terms. A file valid under v0.8.4 is valid under v0.8.5 unchanged | RFC-048 |
| v0.8.4 | source.article: an input calls the decision of an article, named as <regulation>#<article> or by a $-reference to a value that holds one; a $-reference to a decision value calls that decision anew, with its own fields and findings. Without output the input is a decision value {grondslag, fields, findings, outputs}, with it one output of the decision. source.parameters_from: objects merged in order into the parameters of that call, with parameters on top; only with article, and article stands apart from regulation, decisions and endpoint. The field type decision for such a value. derived on the decision item of produces: outputs that are data derived for the decision, computed at its stages but left out of the decision value. Additive: a file valid under v0.8.3 is valid under v0.8.4 unchanged | RFC-050 |
| v0.8.3 | BEZWAAR as a kind of submission, next to AANVRAAG: in produces.submission.kind, as the type of a list item and in a hook’s applies_to.submission. The article that decides on an objection establishes it, and the Awb hooks onto it. Additive: a file valid under v0.8.2 is valid under v0.8.3 unchanged | RFC-050 |
| v0.8.2 | regulatory_layer: REDUCTIE: no regulation, but a reduction of a cell over its own chronicle (RFC-022 §4), kept with the cell and not in the corpus of regulations. source.decisions (<regulation>#<article>): the decisions taken under that article, as a list with one row per decision. It stands alone, without regulation, output, parameters or endpoint. Only a REDUCTIE reads it, only a data source answers it, and a REDUCTIE does not act on law (no implements, hooks, overrides, execution.produces or open_terms). Additive: a file valid under v0.8.1 is valid under v0.8.2 unchanged | RFC-048 |
| v0.8.1 | execution.produces may be a list of produced items instead of one object, such as an application and the decision on it. Each item has a type: a kind of submission (AANVRAAG) or a legal character (BESCHIKKING), one item per type. parameters names the article’s parameters an item contains, outputs the outputs it yields; an item without outputs yields the outputs no other item lists. A submission names the article whose decision it asks for with requests (<regulation>#<article>). A decision may carry decision_type and procedure_id. In a staged execution the hooks on a submission fire at the stage named after its type (AANVRAAG), that stage computes the submission’s outputs, and every other stage computes the decision’s. Descriptions: an open term with decided_per_case_by that no implementation fills takes the authority’s judgement for the case from the execution. The object form is unchanged, so a file valid under v0.8.0 is valid under v0.8.1 unchanged | RFC-047 |
| v0.8.0 | produces.submission (kind: AANVRAAG): the article establishes an application. produces.moment: the moment that counts in law, with a legal_basis citation of the provision behind it. A hook applies to a decision (legal_character) or to a submission (submission, optionally narrowed with established_by), not both. Additive: a file valid under v0.7.1 is valid under v0.8.0 unchanged | RFC-045 |
| v0.7.1 | Descriptions only: six field descriptions said the Rust law-model drops or cannot read a field it does read (endpoint, requires, references, resolve and legal_basis on an action, and the preamble’s machine_readable); they now say what the model and the engine do with it. No keyword that affects validation changed, so a file valid under v0.7.0 is valid under v0.7.1 unchanged | RFC-040 |
| v0.7.0 | placement on articles: the chapter, title, division and paragraph that enclose it, with their headings. markings replaces untranslatables (a flag on an article that is otherwise worked out, with resolution, resolved_by and target), declares records a document property an article establishes, and enables is removed. open_terms gains expected_source, decided_per_case_by and a closed delegation_type. An override can state voids: true with a legal_text_excerpt. Operations DATE_PART and START_OF. Not additive: a file carrying untranslatables or enables does not validate under v0.7.0 and goes through law-migrate | RFC-031, RFC-032, RFC-027 |
| v0.6.0 | No new constructs. Fills in the description of every field that lacked one, rewrites 39 that were already there, and adds examples, so the schema documents itself and this page can render it. Both keywords are annotation-only, so a file valid under v0.5.9 is valid under v0.6.0 unchanged | RFC-040 |
| v0.5.9 | RECHTSPOSITIE added to produces.legal_character and to the hooks.applies_to filter: a legal position of a person that arises by operation of law, without a besluit and without an aanvraag | RFC-038 |
| v0.5.8 | nullable on parameters, inputs and outputs: whether null (absence) is a legitimate value of the field; defaults to false, and the validator and the engine hold a law to it. Also corrects the description of required on execution parameters: it defaults to true, and an omitted required: false parameter is an unknown value, not an error | RFC-036 |
| v0.5.7 | FOREACH operation (iteration over a variable-length collection) | RFC-016 |
| v0.5.6 | Quantity unit labels (euro, ratio, percentage) and structured definitions constants carrying type/type_spec | RFC-023 |
| v0.5.5 | ROUND, CEIL, FLOOR rounding operations (explicit statutory rounding) | RFC-024 |
| v0.5.4 | DATE_DIFF operation; date operands for the comparison operators | RFC-021 |
| v0.5.3 | valid_to (law end date) | RFC-019 |
| v0.5.2 | annotation-schema.json for stand-off notes | RFC-005, RFC-018 |
| v0.5.1 | Tag-based immutable schema URLs; refinements within the v0.5.x line | RFC-013 |
| v0.5.0 | hooks, overrides (reactive execution); procedure, procedure_id (Awb lifecycle); Woo support | RFC-007, RFC-008 |
| v0.4.0 | open_terms, implements (IoC); legal_character; date and array value types | RFC-003 |
| v0.3.2 | SUBTRACT_DATE split into its own date operation with a unit (days, months, years) | |
| v0.3.1 | Structured references on articles (bwb_id, artikel, lid, onderdeel, …) for runtime cross-reference resolution | |
| v0.3.0 | Typed operation definitions (arithmetic, logical, comparison, conditional, switch) with semantic operands and legal_basis, replacing the single untyped operation | RFC-004 |
| v0.2.0 | Initial public schema: regulatory_layer, competent_authority, execution.produces, cross-law references (source) | RFC-001, RFC-002 |
Multi-organization execution (RFC-009) reuses competent_authority (v0.2.0) and adds no schema construct of its own. Absent and unknown values (RFC-036) add one construct, the nullable flag of v0.5.8, and otherwise fix what the engine does with existing constructs over a missing value; v0.5.8 also corrects the wording of required, whose text said “defaults to false” while the engine has always read an absent flag as required.
The annotation schema (annotation-schema.json) versions independently of the law schema: it is republished only when it changes. It was introduced at schema/v0.5.2/ and last republished at schema/v0.5.3/, which is the version the validators embed.
Validate ruleworks against the schema:
Each version of a rulework is one file: the regulation as it reads from one date. These 22 keys sit at the top level; articles carries the text and, where a provision has been translated, its machine_readable section.
namestringpublication_datestring^[0-9]{4}-[0-9]{2}-[0-9]{2}$.
valid_fromstring^([0-9]{4}-[0-9]{2}-[0-9]{2}|#.+)$.
valid_tostring^[0-9]{4}-[0-9]{2}-[0-9]{2}$.
regulatory_layerstringdelegation_type, not by this field alone. REDUCTIE: not a regulation but a cell's reduction over its own chronicle (RFC-022 §4, RFC-048). Since v0.8.12 it sits with its cell (corpus/cells/<cell>/reductions/), or with none (corpus/cells/reductions/), where every cell applies it to its own chronicle, and names no competent_authority: the directory is its holder. Its cell gives its outputs as named answers (the catalogue answers in cel.yaml). It is the only rulework that reads a chronicle. Since v0.8.19 each article with a machine_readable takes one of two forms, and one file may hold both: an aggregate, a projection with per and no execution, which plays the records of the chronicle, decisions and recorded facts alike; or a read model, whose every article with an execution reads the aggregates of another reduction (source.projections, since v0.8.17). Up to v0.8.16 it read decisions directly (source.decisions) and up to v0.8.18 the facts its cell recorded (source.facts, since v0.8.7; source.executograms in v0.8.6, RFC-051). A read model may call law or policy (source.regulation), passing what it reads from the aggregates as parameters. It fills no open term (no implements; v0.8.5 to v0.8.8 allowed it): the policy of the authority that decides binds a term to an answer (source.reduction). Beyond that it does not act on law (no hooks or overrides), takes no decisions (no execution.produces) and delegates nothing (no open_terms).urlstringvalid_from.bwb_idstring^BWBR[0-9]{7}$.
celex_nummerstringelistringtractatenblad_idstringunts_nummerstringgemeente_codestring^GM[0-9]{4}$.
provincie_codestring^PV[0-9]{2}$.
waterschap_codestring^WS[0-9]{4}$.
officiele_titelstringstcrt_idstringorganisationstringcompetent_authoritystring or Named authorityUITVOERINGSBELEID that binds an open term to the answer of a cell (source.reduction) names its holder by name: where the term names no competent authorities, the engine asks the cell of that holder, matched as RFC-052 matches an answerer (an INSTANCE by name, a CATEGORY by category).legal_basisarray of objectlegal_basis a field or action carries, which cites a provision far more precisely.preambleobjectarticlesarray of objectmachine_readable is what makes one executable.procedurearray of objectWhich identifier a file must carry depends on what kind of instrument it is. A national law is identified by its BWB number, an EU regulation by its CELEX number, a municipal ordinance by the CBS municipality code plus its official title. The schema states this as conditional requirements:
A REDUCTIE is no regulation but a cell's reduction over its own chronicle (RFC-048). It needs no identifier, and its articles take no decision, delegate nothing and do not act on law. It is the only layer that may read the decisions taken under an article (source.decisions) and the recorded facts an article requires (source.facts). Its cell gives it as a named answer.
Since v0.8.9 an article of UITVOERINGSBELEID binds an open term to such an answer: it fills the term with implements and takes the answer as an input through source.reduction, with itsparameters and an optional combine (RFC-048). No other layer may take an answer. Such a policy names its holder by name in a top-level competent_authority.
legal_basis[]The articles of higher law that authorize this regulation. Not the same shape as the legal basis a field or action carries: this one names a law by law_id and nothing finer than an article.
law_idstringarticlestringdescriptionstringpreambleThe aanhef, the passage before Article 1 that names the authority the regulation is made under. It carries no operative norm of its own, so it rarely computes anything.
textstringurlstringmachine_readableMachine readable sectionprocedure[]AWB-defined procedure lifecycles for administrative decisions (RFC-008).
idstringdefaultbooleanapplies_toobjectproduces.stagesarray of objectprocedure[].stages[]The lifecycle stages in order, from the application to the final decision. Each names itself and what it needs before it can complete.
namestringdescriptionstringrequiresarray of objectEach entry of articles is one provision: its number, its verbatim text, and the URL it was taken from. machine_readable is present only where the provision has been translated, which for most of the corpus is not yet the case. An article without it is carried as text and nothing more.
numberstringtextstringurlstringmachine_readableMachine readable sectionreferencesarray of objectplacementobjectarticles[].references[]Structured references to other laws and articles. The Rust law-model reads and keeps them, but nothing resolves these at runtime today.
idstringbwb_idstring^BWBR[0-9]{7}$.
artikelstringlidstringonderdeelstringhoofdstukstringparagraafstringafdelingstringarticles[].placementWhere this article sits in the document: the containers that enclose it, each with its number and its opschrift. The opschrift is condensed legal classification written by the legislator, and it decides questions the article text alone cannot answer. Awb 3:9 only makes sense once you can see it sits in 'Afdeling 3.3 Advisering', because the adviseur definition of 3:5 lid 1 is scoped to that division. Absent for an article that no container encloses, which is normal in a short law.
boekobjectdeelobjecthoofdstukobjecttiteldeelobjectafdelingobjectparagraafobjectAn article carries this when it has been translated. It holds the executable part (execution) and the annotations around it: what the article delegates, what it implements, which authority decides, and what could not be translated.
endpointstringcompetent_authoritystring or Named authorityrequiresarray of objectopen_termsarray of objectimplementsarray of objectdefinitionsobjectnaam: 123) or the optionally-structured form carrying a type and type_spec so the constant can declare its quantity-kind (RFC-023): naam: {value: 123, type: amount, type_spec: {unit: eurocent}}.executionobjectprojectionobjectREDUCTIE. Since v0.8.17 a projection plays one aggregate per record of a kind (per): that record, the root, and every record that refers to it through refers_to, directly or through another record of the aggregate. Each record may change the state of its aggregate through the step this reduction gives for its article (steps): the step takes outputs of a law, with parameters from the record and the state, and its actions give properties their values from them. Which records count follows from the effects their laws give (produces[].effects, requires[].effects): a record counts unless a later record that itself counts revokes it. So a record that is revoked revokes nothing, and a record it alone revoked counts again. Only the records that count change the state, in the order the cell recorded them; a root that does not count applies no step, while the other records of its aggregate that count apply theirs. A revoked record is gone from the whole history (ex tunc); a change from a later day on is a step with a date property. The chronicle itself is never changed, and a record recorded after the calculation date is not played. A step is pure: the next state follows from the state before and the record alone, because each output a step takes depends only on what the step passes, and a step passes no parameter of a question. Purity holds per output a step reads, not per article: that output, and every output of its article it reads in turn, reads no input and no open term, while another output of the same article may. Since v0.8.16, when a reduction loads, the loader checks its steps against the laws it holds; a law never depends on a reduction that reads it, so a law that arrives later always loads, and the engine checks the steps again when it plays the projection. One version of this reduction, the one in force on the calculation date, gives every step; the effects of a record come from the version of its law in force on the day it was recorded. The engine records, per property, which record set it last. A projection answers no question of its own and the article has no execution: another reduction reads the last state of each aggregate with source.projections, and answers from those rows. Up to v0.8.16 a projection played the records of one key, answered from its own execution, and a step could pass a parameter of the question.hooksarray of objectoverridesarray of objectmarkingsarray of objectdeclaresarray of objectmachine_readable.requires[]Other provisions this article depends on, and the facts it requires (since v0.8.7). The Rust law-model reads the structure below; the engine does not act on it at runtime.
articlestringlawstringregelingstringkoninklijk_besluitstringvaluesarray of stringfactstringgeneeskundig_onderzoek for 'een geneeskundig onderzoek heeft plaatsgehad'. The law says what the fact holds (parameters), not when it arises or who records it. An entry with fact names no other provision.^[a-z][a-z0-9_]*$.
parametersarray of stringfact: the names of this article's parameters that the fact holds, with their types. Every name must be a parameter of the article; the loader checks it.descriptionstringfact: what the fact is, in words.competent_authorityNamed authority or array of Named authorityfact: who establishes the fact (RFC-052), one named authority or a list, such as the GGD for a medical examination.effectsarray of objectfact: what an instance of this fact does with the record it refers to, as a decision does with produces[].effects. A fact is no decision, but the law can give a recorded fact a legal effect on a decision, such as the receipt of a copy of a ruling that annuls the decision (Awb 8:72 lid 1, 8:79). A fact revokes the record it refers to (refers_to, RFC-053), so which record the fact is about has one source: the receipt of a copy refers to the decision it concerns, and since v0.8.17 any fact may refer to the earlier record it is about; with effects, that is the record it revokes. refers_to names, on every record, the record this record is about. The record does not count, from the start (ex tunc). With when a boolean parameter the fact holds must be true for the effect to hold. The effect reads nothing but the fact, so whether a record counts never depends on the state or on the day asked about. The loader checks that revokes is refers_to and that when names a boolean parameter the fact holds that is not nullable.machine_readable.open_terms[]Abstract values that this article leaves open and that an implementing regulation or implementing policy fills at a lower level. Any regulatory layer can declare open_terms; a law typically has required: true (no default), lower layers often provide defaults that can be refined further down. This is the single place for an open norm, whether the article names who fills it ('bij ministeriele regeling') or leaves that open ('redelijkerwijs'); in the second case delegated_to and delegation_type are simply absent and any competent authority may fill it through implementing policy. Whether the filling regulation is currently in the corpus is a state of the corpus and not a property of the law, so it is not recorded here.
idstringdescriptionstringtypestringrequiredbooleantrue.
delegated_tostringdelegation_typestringlegal_basisstringdefaultobjectimplements. It applies in two cases: no implementing regulation was found, and an implementation ran but returned null for this case.expected_sourcestringdecided_per_case_bystringcompetent_authorityNamed authority or array of Named authoritysource.regulation, one named authority or a list. An engine that routes on competence asks only those. The article's own competent_authority says who decides (RFC-002), which is another question.machine_readable.implements[]Declares that this article fills open terms from a higher-level law. Maps to the 'Gelet op' clause in Dutch legislation. One article can implement multiple open terms from different laws.
lawstringarticlestringopen_termstringgelet_opstringmachine_readable.projectionSince v0.8.14, only in a REDUCTIE. Since v0.8.17 a projection plays one aggregate per record of a kind (per): that record, the root, and every record that refers to it through refers_to, directly or through another record of the aggregate. Each record may change the state of its aggregate through the step this reduction gives for its article (steps): the step takes outputs of a law, with parameters from the record and the state, and its actions give properties their values from them. Which records count follows from the effects their laws give (produces[].effects, requires[].effects): a record counts unless a later record that itself counts revokes it. So a record that is revoked revokes nothing, and a record it alone revoked counts again. Only the records that count change the state, in the order the cell recorded them; a root that does not count applies no step, while the other records of its aggregate that count apply theirs. A revoked record is gone from the whole history (ex tunc); a change from a later day on is a step with a date property. The chronicle itself is never changed, and a record recorded after the calculation date is not played. A step is pure: the next state follows from the state before and the record alone, because each output a step takes depends only on what the step passes, and a step passes no parameter of a question. Purity holds per output a step reads, not per article: that output, and every output of its article it reads in turn, reads no input and no open term, while another output of the same article may. Since v0.8.16, when a reduction loads, the loader checks its steps against the laws it holds; a law never depends on a reduction that reads it, so a law that arrives later always loads, and the engine checks the steps again when it plays the projection. One version of this reduction, the one in force on the calculation date, gives every step; the effects of a record come from the version of its law in force on the day it was recorded. The engine records, per property, which record set it last. A projection answers no question of its own and the article has no execution: another reduction reads the last state of each aggregate with source.projections, and answers from those rows. Up to v0.8.16 a projection played the records of one key, answered from its own execution, and a step could pass a parameter of the question.
statearray of objectnullable. Not id, under which a row of the aggregates holds its root.stepsarray of objectinput with source.regulation), with parameters from the record and the state, and its actions couple each property of the state to one of them. What the record does is in that law. A record without a step leaves the state as it is; its effects on other records still hold.perstring<regulation>#<article>, with #<KIND> where the article gives more than one kind, or since v0.8.18 #<fact>, the name of a fact the article requires, for the instances of that fact alone; since v0.8.18 the loader holds per to its article as it holds a step), such as a decision that grants a permit or the copy of a ruling that suspends one. The aggregate holds that record, its root, and every record that refers to it through refers_to, directly or through another record of the aggregate. Another record of the root's kind that refers in is an aggregate of its own: in this one it counts for its effects only, so a decision in the place of the root revokes it here, while its step is not applied. A state property is not called id: a row of the aggregates holds the id of its root under that name.^[a-z0-9_]+#[A-Za-z0-9]([A-Za-z0-9:._ -]*[A-Za-z0-9])?(#([A-Z][A-Z_]*|[a-z][a-z0-9_]*))?$.
machine_readable.hooks[]Hook declarations: this article fires when matching lifecycle events occur (RFC-007).
hook_pointstringapplies_toanymachine_readable.overrides[]Override declarations: this article replaces another article's output (RFC-007, lex specialis).
lawstring$id of the law whose output is being replaced: lex specialis written down. An override from another law fires only when that law is the one being executed, so with no such context it does not apply (RFC-007). An override on an output of its own law applies whatever the contextual law is, because an exclusion in the same law is not a claim about the asking law (RFC-041). The engine does not check that the override is legally valid.articlestringoutputstringvoidsbooleanlegal_text_excerptstringmarkings already do. A closed vocabulary was considered and rejected: it would make the agent translate the statute into a category, which is the interpretive step this format exists to avoid. A quotation only has to be copied, and a check can hold it against the article's own text.machine_readable.markings[]Constructs in this article that the format itself cannot express. A marking is a flag on an article that is otherwise worked out: it names the one thing that does not fit and leaves everything that does fit standing. A marking that empties an article is a defect, not a translation. Keep it strictly apart from open_terms, which say the opposite: the language can express this fine, the content is filled elsewhere. Replaces untranslatables and norm_gaps from earlier schema versions.
aboutstringreasonstringresolutionstringresolved_bystringtargetarray of stringaccepted and the untranslatable modes of RFC-012, which do not read this field; whether a marking should ever block only the values it names is an open question in RFC-031.legal_text_excerptstringacceptedbooleanfalse.
machine_readable.declares[]Document properties this article establishes. A citation title, a commencement date or a scope in time is not a calculation, and it is not nothing either: it fixes a value the rest of the corpus and every trace depend on. Article 51 of the Awir says what that law is called, and a trace that names the law is quoting that article. Recording it here makes the article accounted for and lets a check hold the document header against the provision that decides it.
propertystringvalueanyapplies_fromstringhooks[].applies_toWhich decisions (legal_character, optionally decision_type and stage) or which submissions (submission, optionally established_by, RFC-045) of other articles this hook fires on. A hook names one of the two.
legal_characterstringtype in the list form (RFC-047).decision_typestringstagestringsubmissionstringtype in the list form (RFC-047). A hook names either legal_character or submission (RFC-045). For an article that follows a procedure, a staged execution fires the hook at the stage named after the kind (RFC-047).established_byArticle reference<regulation>#<article>) establishes. Without it the hook applies to every submission of the kind.The executable core. Values come in as parameters andinput, actions compute, and outputdeclares what the article yields.
producesobject or array of Produced itemparametersarray of Parameter fieldinputarray of Input fieldsource.outputarray of Output fieldactionsarray of Actionexecution.producesWhat executing this article yields in legal terms. One object for an article that yields one thing, the form most laws use. A list when the article yields more than one thing, such as an application and the decision on it, each item with its own type, parameters and outputs (RFC-047).
legal_characterstringdecision_typestringGEEN_BESLUIT is the value for an article that establishes a fact rather than deciding anything.procedure_idstringsubmissionobjectmomentobjectexecution.produces[]Several things the article yields, each its own item with a type, such as an application (AANVRAAG) and the decision on it (BESCHIKKING), with the parameters and outputs that belong to each (RFC-047).
typestringrequestsArticle reference<regulation>#<article>, also when that is this article (Awb 1:3 lid 3, Awb 4:2 lid 1 onder c). The target is that article's decision: the item with a decision type in the list form, or the article itself in the object form with a legal_character. The loader checks a target in the same law; a target in another law is checked when it is used (RFC-047).parametersarray of stringoutputsarray of stringderived. Every name must be an output of the article; the loader checks it. Every output belongs to exactly one item, under outputs or, for data derived for the decision, under derived (RFC-047, RFC-050). In a staged execution, the stage named after a submission's type computes that submission's outputs, and every other stage those of the decision with the data derived for it.derivedarray of stringsource.article) leaves them out of the decision value. Derived data is listed, never inferred: an output that no item lists under outputs or derived is refused, so a forgotten or misspelt output fails instead of turning into derived data. Every name must be an output of the article and belongs to no other item; the loader checks both.effectsarray of objectwhen a boolean output of this decision that must be true for the effect to hold. From the effects a runtime that records decisions and facts derives which records count: a record counts unless a later record that itself counts revokes it. A revoked record has no consequences and revokes nothing, so a record it alone revoked counts again; a new decision that should keep a revocation in force declares that effect itself. A revocation takes a record out of the whole history (ex tunc). A change from a later day on (ex nunc), such as a suspension or a withdrawal with effect from a date, is no effect: it is a step of the reduction with a date property, and whether the record counts never depends on the day asked about. From v0.8.17 a decision revokes only a record it is about: its refers_to names that record, or names a record that refers to it in turn, as a decision on an objection refers to the objection and the objection to the decision it contests. A decision taken on no submission, such as a withdrawal ex officio, refers to the decision it affects. The cell and the engine refuse a decision that revokes another record; they count no fixed number of steps, so a decision on an objection (Awb 7:11) and one the court puts in place (Awb 8:72) follow the same rule. refers_to names, on every record, the record this record is about. A fact the article requires may have effects as well (requires[].effects, since v0.8.15). The engine carries the effects out when it plays a chronicle through a reduction with a projection; the loader checks that it sits on a decision, that every named parameter is a parameter of the article (from v0.8.15 a string or decision parameter that is not nullable), and that every when names a boolean output of the decision.decision_typestringprocedure_idstringmomentobjectOne assignment to one output. It either states a literal valueor computes one with an operation, never both.
outputstringvalueOperation valueoperation, that operation wins and this field is read as one of its operands.operationOperation typevalue, this wins and that field is read as an operand.valuesarray of Operation valueprecisionintegerresolveobjectlegal_basisLegal basisaction.resolveLook up the value in whichever regulation implements it. The Rust law-model reads it, but the engine does not execute it yet; no law in the corpus uses it.
typestringoutputstringmatchobjectParameters, inputs and outputs share one shape and add to it. Note the singular spelling: the keys are input and output, not their plurals.
Every parameter, input and output carries these. The three kinds below repeat them, so each section is the complete list for that kind.
namestring$name. This is the name another law asks for when it reads this value through source, so renaming an output is a change other laws can see.descriptionstringtypestringamount is counted in is declared separately, in type_spec.unit; units are opt-in per law, and an un-annotated value has unit unknown and is never checked (RFC-023). A decision is a decision value {basis, fields, findings, outputs}: the article that decided (<regulation>#<article>), the parameters that article was given and declares, its findings per case (the open terms it leaves to an authority per case, decided_per_case_by, under their ids), and the outputs of its decision item (RFC-050). A value built from a recorded decision may also carry taken_on: the article that established the submission the decision was taken on.nullablebooleannull (absence: the register or the law says there is none) is a legitimate value of this field. Defaults to false: a non-nullable input may never receive null from a data source, another law or a caller, a non-nullable output may never evaluate to null, and a non-nullable parameter may never be passed null. On a required parameter the flag means the same at the top level and across laws: a nullable one is run with the null and decides on it, a non-nullable one is a caller error at the top level and skips the call across laws. Unknown (a value nobody has) is not governed by this flag. RFC-036.type_specobjecttemporalobjectlegal_basisLegal basisfield.type_specAdditional type specifications for numeric and temporal values.
unitstringratio (0-1) and percentage (0-100) are distinct labels; any division by 100 is an explicit value operation, never implied by the label.precisionintegerminnumbermaxnumberfield.temporalHow the value relates to time: whether it is measured at a moment or over a period, and which date it is anchored to (RFC-001). Declared in the schema but not yet read by the engine, and unused in the corpus.
typestringperiod_typestringreferencestring or Variable referenceA value the caller passes in, rather than one the law looks up or derives. Adds required, which defaults to true; an omitted required: false parameter resolves to an unknown value rather than an error (RFC-036).
namestring$name. This is the name another law asks for when it reads this value through source, so renaming an output is a change other laws can see.descriptionstringtypestringamount is counted in is declared separately, in type_spec.unit; units are opt-in per law, and an un-annotated value has unit unknown and is never checked (RFC-023). A decision is a decision value {basis, fields, findings, outputs}: the article that decided (<regulation>#<article>), the parameters that article was given and declares, its findings per case (the open terms it leaves to an authority per case, decided_per_case_by, under their ids), and the outputs of its decision item (RFC-050). A value built from a recorded decision may also carry taken_on: the article that established the submission the decision was taken on.nullablebooleannull (absence: the register or the law says there is none) is a legitimate value of this field. Defaults to false: a non-nullable input may never receive null from a data source, another law or a caller, a non-nullable output may never evaluate to null, and a non-nullable parameter may never be passed null. On a required parameter the flag means the same at the top level and across laws: a nullable one is run with the null and decides on it, a non-nullable one is a caller error at the top level and skips the call across laws. Unknown (a value nobody has) is not governed by this flag. RFC-036.type_specobjecttemporalobjectlegal_basisLegal basisrequiredbooleanrequired: false that the caller omits resolves to an unknown value that names the parameter (RFC-036), so a law can declare application-form fields another law never passes. A step of a projection (since v0.8.16) need pass only the required parameters that the output it takes reads, directly or through another output of its article.columnsarray of Array columnarray: the columns of each row, so the parameter holds a table. A property of the state of a projection that a step fills from such a parameter (an array with columns) must declare the same columns, each with the same type; the loader checks it. Only that comparison and the rows a step puts in the state are checked; the engine does not hold a value passed for the parameter to its columns otherwise. Without columns the rows of the array are not declared, and the loader checks nothing about them.A value the law looks up elsewhere: another law's output, or a fact from a register. Adds source, which is required and says where the value comes from (RFC-007).
namestring$name. This is the name another law asks for when it reads this value through source, so renaming an output is a change other laws can see.descriptionstringtypestringamount is counted in is declared separately, in type_spec.unit; units are opt-in per law, and an un-annotated value has unit unknown and is never checked (RFC-023). A decision is a decision value {basis, fields, findings, outputs}: the article that decided (<regulation>#<article>), the parameters that article was given and declares, its findings per case (the open terms it leaves to an authority per case, decided_per_case_by, under their ids), and the outputs of its decision item (RFC-050). A value built from a recorded decision may also carry taken_on: the article that established the submission the decision was taken on.nullablebooleannull (absence: the register or the law says there is none) is a legitimate value of this field. Defaults to false: a non-nullable input may never receive null from a data source, another law or a caller, a non-nullable output may never evaluate to null, and a non-nullable parameter may never be passed null. On a required parameter the flag means the same at the top level and across laws: a nullable one is run with the null and decides on it, a non-nullable one is a caller error at the top level and skips the call across laws. Unknown (a value nobody has) is not governed by this flag. RFC-036.type_specobjecttemporalobjectlegal_basisLegal basissourceobjectinput[].sourceReference to where this input comes from.
regulationstringoutputstringparametersobject$-reference to a value in scope, as in bsn: $bsn.descriptionstringendpointstringreductionstringanswers in cel.yaml). Only an article of UITVOERINGSBELEID that fills an open term (implements) takes one: it binds the term to the answer, and its policy names its holder (competent_authority). parameters gives the values the answer takes, under the names the cell's reduction declares; one it declares and the binding does not pass is an error. The engine asks one cell of the execution: the cell the filled term names in its competent_authority (RFC-052), or else the cell of the policy's holder. Where the execution holds more than one cell the term names, the input is an error at run time: one question goes to one cell, and the engine merges no answers. A cell without an answer of that name, or with a null one, is silent. Without an answer the input is null, so the binding fills nothing and the term is what it is without it, such as the finding of the deciding authority; an input that takes an answer is therefore declared nullable: true, and one that is not is an error at run time when no cell answers. It stands alone, without regulation, output, endpoint or article.^[a-z][a-z0-9_]*$.
articleArticle reference or Variable reference<regulation>#<article>, or a $-reference to a value that holds one, such as the basis of a decision value, or that is a decision value itself. A decision value is called anew: the engine runs its basis with its own fields as parameters and its own findings. Without output the engine runs the decision item of that article at stage BESLUIT, and the input is a decision value {basis, fields, findings, outputs}. With output, the input is that one output of the decision item. The article is the one in force on the calculation date; one that is not in force, or that takes no decision, is an error at run time. The parameters are the fields of a decision value, then those of parameters_from, with parameters on top; a name the article does not declare is dropped, and the trace names it, unless it is the id of an open term the article leaves to an authority per case (decided_per_case_by): that is the finding for this case, kept under findings, not fields. A finding the caller of the engine gives for the execution, apart from the parameters, wins over one the call passes, and an implementation of the term still wins over both (RFC-047). It stands apart from regulation, decisions and endpoint.parameters_fromarray of Variable referencearticle as parameters, merged in order: a later one wins over an earlier one, and parameters wins over all of them. Each is an object, such as the fields or findings of a decision value, or null, which adds nothing; any other value is an error at run time. Only with article.projectionsstringprojection. Since v0.8.19 it names the article of the aggregate, <regulation>#<article>, also when that article is in the reading file itself; up to v0.8.18 it named the $id of the reduction alone. The article must play one aggregate per record (projection.per). A list with one row per root record the chronicle holds on the calculation date: the last state of its aggregate, with the root's id. With where, only the roots that hold each named value, as a field or an output. Only a REDUCTIE reads it, and the cell that runs the reduction plays the aggregates on its own chronicle; no regulation is executed for it, so it stands alone, without regulation, output, parameters, endpoint, reduction or article. Without a chronicle the input is an error, never an empty list.^[a-z0-9_]+#[A-Za-z0-9]([A-Za-z0-9:._ -]*[A-Za-z0-9])?$.
whereobjectprojections: the roots whose aggregates are read, by the values they hold. A map from the name of a field or output of the root to a $-reference to a parameter of the reading article; a root that holds another value under a name, or none, is left out. Numbers compare by value.A value the article yields. Adds nothing to the common fields, and that is the point: every output is callable from another law through source, which asks for it by name (RFC-007). Callable is not the same as presentable, and what a portal offers a citizen is derived from produces, not from a flag on the output (RFC-038).
namestring$name. This is the name another law asks for when it reads this value through source, so renaming an output is a change other laws can see.descriptionstringtypestringamount is counted in is declared separately, in type_spec.unit; units are opt-in per law, and an un-annotated value has unit unknown and is never checked (RFC-023). A decision is a decision value {basis, fields, findings, outputs}: the article that decided (<regulation>#<article>), the parameters that article was given and declares, its findings per case (the open terms it leaves to an authority per case, decided_per_case_by, under their ids), and the outputs of its decision item (RFC-050). A value built from a recorded decision may also carry taken_on: the article that established the submission the decision was taken on.nullablebooleannull (absence: the register or the law says there is none) is a legitimate value of this field. Defaults to false: a non-nullable input may never receive null from a data source, another law or a caller, a non-nullable output may never evaluate to null, and a non-nullable parameter may never be passed null. On a required parameter the flag means the same at the top level and across laws: a nullable one is run with the null and decides on it, a non-nullable one is a caller error at the top level and skips the call across laws. Unknown (a value nobody has) is not governed by this flag. RFC-036.type_specobjecttemporalobjectlegal_basisLegal basisA citation back to the provision a value or a step rests on. Any field, any action and any operation may carry one; it is what lets an execution trace name the article behind each number rather than only the number.
lawstringbwb_idstring^BWBR[0-9]{7}$.
articlestringparagraphstringsentencestringurlstringjuriconnectstringz=/g= parameters; most references in the corpus carry them, and the pattern does not require them.^jci1\.3:c:BWBR[0-9]{7}(&[a-zA-Z_]+=.+)*$.
explanationstringSince v0.8.20: one column of an array of rows, in which each element is an object with a value per column. The column has a name and a scalar type. A row lacking a column holds null there; a row with a column not declared is refused.
namestring$<row>.<name> in the body of a FOREACH over the array.^[a-z_][a-z0-9_]*$.
typestringnullable.descriptionstringAn article of a regulation, <regulation>#<article>, without lid <n>. The article holds letters, digits, :, ., _, - and spaces (Kieswet G 1, Awb 4:13), and starts and ends with a letter or digit.
^[a-z0-9_]+#[A-Za-z0-9]([A-Za-z0-9:._ -]*[A-Za-z0-9])?$Variable reference starting with $ (e.g., $standaardpremie, $referencedate.year). Supports dot notation for property access.
^\$[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$An action either states a literal value or computes one with anoperation. There are 16 forms. Each is a closed object: the operation key picks the form and the schema rejects any other combination of keys, so a malformed action fails validation rather than executing as something unintended.
Wherever an operation below takes a value, three things may stand there:
Arithmetic operations that compute numeric values.
valuesarray of Operation valuelegal_basisLegal basisRounding operations (RFC-024). Round the single operand to precision decimal places, in the value's own unit (RFC-023). Rounding is never implicit - a law that rounds must say so here. ROUND is half-up (rekenkundig, the Hoge Raad default); CEIL rounds up (naar boven); FLOOR rounds down (naar beneden / afkapping).
valueOperation valueprecisionintegerlegal_basisLegal basisLogical operations that combine boolean conditions.
conditionsarray of Operation valuelegal_basisLegal basisComparison operations that compare values. Operands may be numbers or ISO 8601 dates (YYYY-MM-DD); when both operands are dates they are compared chronologically (RFC-021). value is required: all five of these compare two operands, and a comparison with only a subject compares against nothing. It was optional, and the Rust model's untagged fallback turned such an operation into a literal object without an error, a warning or a line in the trace, so the execution carried on and produced an answer that looked complete.
subjectOperation valuevalueOperation valuelegal_basisLegal basisLogical NOT - negates a boolean value.
valueOperation valuelegal_basisLegal basisConditional operation with multiple cases evaluated in order.
casesarray of objectwhen holds decides the value. Order is significant, so a narrower case belongs before a broader one.defaultOperation valuenullable. A case whose condition is unknown takes neither its branch nor the default.legal_basisLegal basisIF.cases[]Cases evaluated in order; the first whose when holds decides the value. Order is significant, so a narrower case belongs before a broader one.
whenOperation valuethenOperation valueMembership test - checks if subject is in a list.
subjectOperation valuevalueOperation valuevalues instead to write the list inline.valuesarray of Operation valuelegal_basisLegal basisConstruct an array from items.
itemsarray of Operation valuelegal_basisLegal basisIterate over a collection, evaluating an expression per element (RFC-016).
collectionOperation valueasstring^[a-z_][a-z0-9_]*$.
filterOperation valuebodyOperation valuecombinestringONLY (since v0.8.6) gives the one result the filter leaves, of any type, such as the record in force on a day: null when it leaves none, an error at run time when it leaves more than one. DISTINCT (since v0.8.21) gives the unique results as an array, in the order of their first occurrence; two results are the same when EQUALS says so, a number, amount, string, date or boolean by value, a row field by field and a list element by element in order. Null is a value and stays once; an empty collection gives an empty array. One value from several equal ones is ONLY over the result of DISTINCT.legal_basisLegal basisCalculate age in complete years between two dates.
date_of_birthOperation valuereference_dateOperation valuelegal_basisLegal basisAdd years, months, weeks, and/or days to a date. Applied coarsest-to-finest: years → months → weeks → days. Month/year additions use the Dutch legal 'corresponding numbered day' rule: the day is clamped to the last day of the target month (e.g., Jan 31 + 1 month = Feb 28).
dateOperation valueyearsOperation valuemonthsOperation valueweeksOperation valuedaysOperation valuelegal_basisLegal basisConstruct a date from year, month, day components.
yearOperation valuemonthOperation valuedayOperation valuelegal_basisLegal basisGet the day of the week (0=Monday, 6=Sunday).
dateOperation valuelegal_basisLegal basisSigned difference between two dates, expressed in a chosen unit. Positive when 'to' is on or after 'from'. Months and years count complete calendar units (RFC-021).
fromOperation valuetoOperation valueinstring or Variable referencelegal_basisLegal basisRead one calendar component out of a date. The inverse of DATE, so 'in' ranges over exactly the components DATE takes. Returns an integer: the year number, the month number (1-12) or the day of the month (1-31). A month number is only meaningful within one year — comparing two month numbers across a year boundary is almost always wrong. For the weekday, use DAY_OF_WEEK.
dateOperation valueinstringlegal_basisLegal basisTruncate a date down to the start of the calendar unit it falls in: 1 January of its year, or the first day of its month. Returns a date (ISO 8601 YYYY-MM-DD). For 'the first day of the month following', truncate first and add afterwards — DATE_ADD over START_OF — so the day-clamping of DATE_ADD never comes into play and the first of the month yields the next first.
dateOperation valueinstringlegal_basisLegal basisThe closed value sets a law picks from. These are the terms the rest of the documentation uses, so each one links to where it is explained.
regulatory_layerType of legal instrument (regelgevingslaag). It fixes which identifier the file must carry, and it ranks candidates when several regulations implement the same open term. Which layer may implement a term is set by that term's delegation_type, not by this field alone. REDUCTIE: not a regulation but a cell's reduction over its own chronicle (RFC-022 §4, RFC-048). Since v0.8.12 it sits with its cell (corpus/cells/<cell>/reductions/), or with none (corpus/cells/reductions/), where every cell applies it to its own chronicle, and names no competent_authority: the directory is its holder. Its cell gives its outputs as named answers (the catalogue answers in cel.yaml). It is the only rulework that reads a chronicle. Since v0.8.19 each article with a machine_readable takes one of two forms, and one file may hold both: an aggregate, a projection with per and no execution, which plays the records of the chronicle, decisions and recorded facts alike; or a read model, whose every article with an execution reads the aggregates of another reduction (source.projections, since v0.8.17). Up to v0.8.16 it read decisions directly (source.decisions) and up to v0.8.18 the facts its cell recorded (source.facts, since v0.8.7; source.executograms in v0.8.6, RFC-051). A read model may call law or policy (source.regulation), passing what it reads from the aggregates as parameters. It fills no open term (no implements; v0.8.5 to v0.8.8 allowed it): the policy of the authority that decides binds a term to an answer (source.reduction). Beyond that it does not act on law (no hooks or overrides), takes no decisions (no execution.produces) and delegates nothing (no open_terms).
machine_readable.execution.produces.legal_characterLegal character of the output. BESCHIKKING: a besluit not of general scope (Awb art. 1:3 lid 2). RECHTSPOSITIE: a legal position of a person that arises by operation of law, without a besluit and without an aanvraag (voting rights, majority, nationality). UITSPRAAK (since v0.8.10): the judgment of an administrative court on an appeal (Awb 8:70); no besluit, because a court is no bestuursorgaan (Awb 1:1 lid 2 onder c) (RFC-053).
machine_readable.execution.produces.decision_typeThe kind of decision this output is, within its legal character. GEEN_BESLUIT is the value for an article that establishes a fact rather than deciding anything.
type / type_spec.unitValue type. What an amount is counted in is declared separately, in type_spec.unit; units are opt-in per law, and an un-annotated value has unit unknown and is never checked (RFC-023). A decision is a decision value {basis, fields, findings, outputs}: the article that decided (<regulation>#<article>), the parameters that article was given and declares, its findings per case (the open terms it leaves to an authority per case, decided_per_case_by, under their ids), and the outputs of its decision item (RFC-050). A value built from a recorded decision may also carry taken_on: the article that established the submission the decision was taken on.
type_spec.unitUnit of measurement for the value (RFC-023). A label, never a computational constraint: tagging a value never changes it. ratio (0-1) and percentage (0-100) are distinct labels; any division by 100 is an explicit value operation, never implied by the label.
The sections above are generated from the released schema at build time, so this page cannot describe a schema other than the released one. That guard is about the version, not the wording: a description that has fallen behind what the engine does is still a description this page will render faithfully. RFC-040 sets out why the schema carries its own documentation and how the generated page is held to it.
The version history is not generated: it records what a version introduced and why, which is a judgement no schema can state about itself.
The schema is JSON Schema draft-07. It uses none of the constructs that changed in later drafts, so it would migrate to 2020-12 mechanically; the one keyword that would be worth having is deprecated, which arrived in 2019-09. That is a decision for its own RFC, since the schema is a contract other engines read (RFC-013) and draft-07 is the most widely implemented dialect.
One consequence of draft-07 shows up here. Where a field is a $ref to another definition, a description written next to that $ref is formally ignored: draft-07 says a $ref replaces its siblings. This page reads those descriptions anyway, falling back to the target’s, so nothing is lost in what you see. An editor that follows the specification strictly will not show them.
An exploration into transparent, executable legislation, and one of the three projects in the starting selection of the Nederlandse Digitale Dienst.
GitHub repository
How it works
Stay informed
Roadmap (Dutch)
Documentation
Research
Nederlandse Digitale Dienst
Ministry of Economic Affairs and Climate Policy