---
title: "workspaceRule"
url: https://developers.dagio.ai/reference/workspace-rule/
---

# workspaceRule

   
                      
                                                                        
                                
                  
           
          
   

This reference describes the full structure of `workspaceRule`. Paths include nested objects, list items and conditional branches. A branch selected by `kind`, `contract` or `mode` only admits its own properties.

## Structure and values

| Field | Options / expected values | Description |
| --- | --- | --- |
| `key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `label` | `string; min length 1; max length 4000` | **Required.** Human-readable label displayed in the interface. |
| `expression` | `recursive reference OR closed object OR closed object OR closed object` | **Required.** Declarative condition tree whose references and budgets are validated before evaluation. |
| `expression.[variant 1].[kind=present].kind` | `"present"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=present].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 1].[kind=present].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 1].[kind=present].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 1].[kind=compare].kind` | `"compare"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=compare].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 1].[kind=compare].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 1].[kind=compare].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 1].[kind=compare].operator` | `"eq" \| "ne" \| "lt" \| "lte" \| "gt" \| "gte"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 1].[kind=compare].value` | `string; max length 4000 OR number OR true \| false OR null` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 1].[kind=in].kind` | `"in"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=in].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 1].[kind=in].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 1].[kind=in].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 1].[kind=in].values` | `Array<string; max length 4000 OR number OR true \| false OR null>; min length 1; max length 100` | **Required.** Set of admitted or compared values according to the declared operation. |
| `expression.[variant 1].[kind=relation].kind` | `"relation"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=relation].linkTypePath` | `string; min length 1; max length 4000` | **Required.** Defines link Type Path for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 1].[kind=relation].direction` | `"incoming" \| "outgoing"` | **Required.** Traversal or presentation direction using this contract’s closed values. |
| `expression.[variant 1].[kind=relation].minimum` | `integer; ≥ 0` | **Required.** Cardinality or budget bound for the named resource. Exceeding the bound is refused; null denotes no bound only where admitted by the schema. |
| `expression.[variant 1].[kind=relation].maximum` | `integer; ≥ 0; null` | **Required.** Cardinality or budget bound for the named resource. Exceeding the bound is refused; null denotes no bound only where admitted by the schema. |
| `expression.[variant 1].[kind=query].kind` | `"query"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=query].queryKey` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Reference to a declared Query; scope and authorization remain enforced by the data engine. |
| `expression.[variant 1].[kind=query].parameters` | `Record<string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u OR string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u, closed object OR closed object OR closed object>; semantic validation; optional` | Optional. Named operation or Query parameters and their associated values. |
| `expression.[variant 1].[kind=query].parameters{key}.[kind=entity-id].kind` | `"entity-id"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=query].parameters{key}.[kind=entity-id].definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 1].[kind=query].parameters{key}.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=query].parameters{key}.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 1].[kind=query].parameters{key}.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 1].[kind=query].parameters{key}.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 1].[kind=query].parameters{key}.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=query].parameters{key}.[kind=literal].value` | `string; max length 4000 OR number OR true \| false OR null` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 1].[kind=query].operator` | `"eq" \| "lt" \| "lte" \| "gt" \| "gte"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 1].[kind=query].value` | `number` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 1].[kind=query-evaluation].kind` | `"query-evaluation"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=query-evaluation].queryKey` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Reference to a declared Query; scope and authorization remain enforced by the data engine. |
| `expression.[variant 1].[kind=query-evaluation].parameters` | `Record<string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u OR string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u, closed object OR closed object OR closed object>; semantic validation; optional` | Optional. Named operation or Query parameters and their associated values. |
| `expression.[variant 1].[kind=query-evaluation].parameters{key}.[kind=entity-id].kind` | `"entity-id"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=query-evaluation].parameters{key}.[kind=entity-id].definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 1].[kind=query-evaluation].parameters{key}.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=query-evaluation].parameters{key}.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 1].[kind=query-evaluation].parameters{key}.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 1].[kind=query-evaluation].parameters{key}.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 1].[kind=query-evaluation].parameters{key}.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=query-evaluation].parameters{key}.[kind=literal].value` | `string; max length 4000 OR number OR true \| false OR null` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 1].[kind=all].kind` | `"all"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=all].operands` | `Array<recursive reference>; min length 1; max length 20` | **Required.** Child expressions combined by the current boolean operator. |
| `expression.[variant 1].[kind=all].operands[] ↻` | `recursive reference to parent expression` | Optional. Defines operands ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 1].[kind=any].kind` | `"any"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=any].operands` | `Array<recursive reference>; min length 1; max length 20` | **Required.** Child expressions combined by the current boolean operator. |
| `expression.[variant 1].[kind=any].operands[] ↻` | `recursive reference to parent expression` | Optional. Defines operands ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 1].[kind=not].kind` | `"not"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 1].[kind=not].operand` | `recursive reference` | **Required.** Child expression evaluated by the current operator. |
| `expression.[variant 1].[kind=not].operand ↻` | `recursive reference to parent expression` | Optional. Defines operand ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].kind` | `"exact-compare"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].operator` | `"eq" \| "ne" \| "lt" \| "lte" \| "gt" \| "gte"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=exact-compare].left` | `recursive reference` | **Required.** Defines left for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=literal].value` | `string; max length 1003` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].kind` | `"calculation"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=calculation].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].kind` | `"arithmetic"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].operator` | `"add" \| "subtract" \| "multiply" \| "divide"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].left` | `recursive reference` | **Required.** Defines left for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].left ↻` | `recursive reference to parent expression` | Optional. Defines left ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].right` | `recursive reference` | **Required.** Defines right for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].right ↻` | `recursive reference to parent expression` | Optional. Defines right ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].rounding` | `"half-even" \| "half-up" \| "toward-zero" \| "away-from-zero" \| "floor" \| "ceiling"; null` | **Required.** Defines rounding for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].unitOperation` | `closed object; null` | **Required.** Defines unit Operation for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].unitOperation.key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=arithmetic].unitOperation.version` | `string; min length 1; max length 120` | **Required.** Declared content or publication version identifying the applicable interpretation. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].kind` | `"round"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].operand` | `recursive reference` | **Required.** Child expression evaluated by the current operator. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].operand ↻` | `recursive reference to parent expression` | Optional. Defines operand ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=round].rounding` | `"half-even" \| "half-up" \| "toward-zero" \| "away-from-zero" \| "floor" \| "ceiling"` | **Required.** Defines rounding for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].kind` | `"conditional"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].condition` | `closed object` | **Required.** Defines condition for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].condition.kind` | `"compare"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].condition.operator` | `"eq" \| "ne" \| "lt" \| "lte" \| "gt" \| "gte"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].condition.left` | `recursive reference` | **Required.** Defines left for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].condition.left ↻` | `recursive reference to parent expression` | Optional. Defines left ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].condition.right` | `recursive reference` | **Required.** Defines right for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].condition.right ↻` | `recursive reference to parent expression` | Optional. Defines right ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].whenTrue` | `recursive reference` | **Required.** Defines when True for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].whenTrue ↻` | `recursive reference to parent expression` | Optional. Defines when True ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].whenFalse` | `recursive reference` | **Required.** Defines when False for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].whenFalse ↻` | `recursive reference to parent expression` | Optional. Defines when False ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conditional].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].kind` | `"conversion"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].conversionKey` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable key reference to the corresponding named declaration; the compiler checks existence and compatibility. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].conversionVersion` | `string; min length 1; max length 120` | **Required.** Defines conversion Version for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].operand` | `recursive reference` | **Required.** Child expression evaluated by the current operator. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].operand ↻` | `recursive reference to parent expression` | Optional. Defines operand ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=conversion].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].kind` | `"query-total"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].queryKey` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Reference to a declared Query; scope and authorization remain enforced by the data engine. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].parameters` | `Record<string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u OR string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u, closed object OR closed object OR closed object>; semantic validation` | **Required.** Named operation or Query parameters and their associated values. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].parameters{key}.[kind=entity-id].kind` | `"entity-id"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].parameters{key}.[kind=entity-id].definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].parameters{key}.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].parameters{key}.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].parameters{key}.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].parameters{key}.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].parameters{key}.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].parameters{key}.[kind=literal].value` | `string; max length 4000 OR number OR true \| false OR null` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].operator` | `"count" \| "count-distinct"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=query-total].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].kind` | `"aggregate"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].queryKey` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Reference to a declared Query; scope and authorization remain enforced by the data engine. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].parameters` | `Record<string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u OR string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u, closed object OR closed object OR closed object>; semantic validation` | **Required.** Named operation or Query parameters and their associated values. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].parameters{key}.[kind=entity-id].kind` | `"entity-id"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].parameters{key}.[kind=entity-id].definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].parameters{key}.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].parameters{key}.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].parameters{key}.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].parameters{key}.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].parameters{key}.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].parameters{key}.[kind=literal].value` | `string; max length 4000 OR number OR true \| false OR null` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].operator` | `"sum" \| "min" \| "max" \| "average"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].left.[kind=aggregate].rounding` | `"half-even" \| "half-up" \| "toward-zero" \| "away-from-zero" \| "floor" \| "ceiling"; null` | **Required.** Defines rounding for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right` | `recursive reference` | **Required.** Defines right for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=literal].value` | `string; max length 1003` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].kind` | `"calculation"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=calculation].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].kind` | `"arithmetic"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].operator` | `"add" \| "subtract" \| "multiply" \| "divide"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].left` | `recursive reference` | **Required.** Defines left for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].left ↻` | `recursive reference to parent expression` | Optional. Defines left ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].right` | `recursive reference` | **Required.** Defines right for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].right ↻` | `recursive reference to parent expression` | Optional. Defines right ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].rounding` | `"half-even" \| "half-up" \| "toward-zero" \| "away-from-zero" \| "floor" \| "ceiling"; null` | **Required.** Defines rounding for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].unitOperation` | `closed object; null` | **Required.** Defines unit Operation for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].unitOperation.key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=arithmetic].unitOperation.version` | `string; min length 1; max length 120` | **Required.** Declared content or publication version identifying the applicable interpretation. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].kind` | `"round"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].operand` | `recursive reference` | **Required.** Child expression evaluated by the current operator. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].operand ↻` | `recursive reference to parent expression` | Optional. Defines operand ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=round].rounding` | `"half-even" \| "half-up" \| "toward-zero" \| "away-from-zero" \| "floor" \| "ceiling"` | **Required.** Defines rounding for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].kind` | `"conditional"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].condition` | `closed object` | **Required.** Defines condition for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].condition.kind` | `"compare"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].condition.operator` | `"eq" \| "ne" \| "lt" \| "lte" \| "gt" \| "gte"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].condition.left` | `recursive reference` | **Required.** Defines left for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].condition.left ↻` | `recursive reference to parent expression` | Optional. Defines left ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].condition.right` | `recursive reference` | **Required.** Defines right for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].condition.right ↻` | `recursive reference to parent expression` | Optional. Defines right ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].whenTrue` | `recursive reference` | **Required.** Defines when True for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].whenTrue ↻` | `recursive reference to parent expression` | Optional. Defines when True ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].whenFalse` | `recursive reference` | **Required.** Defines when False for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].whenFalse ↻` | `recursive reference to parent expression` | Optional. Defines when False ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conditional].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].kind` | `"conversion"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].conversionKey` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable key reference to the corresponding named declaration; the compiler checks existence and compatibility. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].conversionVersion` | `string; min length 1; max length 120` | **Required.** Defines conversion Version for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].operand` | `recursive reference` | **Required.** Child expression evaluated by the current operator. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].operand ↻` | `recursive reference to parent expression` | Optional. Defines operand ↻ for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=conversion].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].kind` | `"query-total"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].queryKey` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Reference to a declared Query; scope and authorization remain enforced by the data engine. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].parameters` | `Record<string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u OR string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u, closed object OR closed object OR closed object>; semantic validation` | **Required.** Named operation or Query parameters and their associated values. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].parameters{key}.[kind=entity-id].kind` | `"entity-id"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].parameters{key}.[kind=entity-id].definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].parameters{key}.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].parameters{key}.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].parameters{key}.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].parameters{key}.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].parameters{key}.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].parameters{key}.[kind=literal].value` | `string; max length 4000 OR number OR true \| false OR null` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].operator` | `"count" \| "count-distinct"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=query-total].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].kind` | `"aggregate"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].queryKey` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Reference to a declared Query; scope and authorization remain enforced by the data engine. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].parameters` | `Record<string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u OR string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u, closed object OR closed object OR closed object>; semantic validation` | **Required.** Named operation or Query parameters and their associated values. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].parameters{key}.[kind=entity-id].kind` | `"entity-id"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].parameters{key}.[kind=entity-id].definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].parameters{key}.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].parameters{key}.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].parameters{key}.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].parameters{key}.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].parameters{key}.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].parameters{key}.[kind=literal].value` | `string; max length 4000 OR number OR true \| false OR null` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].operator` | `"sum" \| "min" \| "max" \| "average"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type` | `closed object` | **Required.** Defines type for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type.format` | `closed object; semantic validation` | **Required.** Presentation format compatible with the value type. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type.format.precision` | `integer; ≥ 1; ≤ 1000` | **Required.** Defines precision for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type.format.scale` | `integer; ≥ 0; ≤ 1000` | **Required.** Defines scale for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].type.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=exact-compare].right.[kind=aggregate].rounding` | `"half-even" \| "half-up" \| "toward-zero" \| "away-from-zero" \| "floor" \| "ceiling"; null` | **Required.** Defines rounding for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=integer-compare].kind` | `"integer-compare"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=integer-compare].schema` | `closed object` | **Required.** Defines schema for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=integer-compare].schema.kind` | `"integer"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=integer-compare].schema.minimum` | `string; max length 1001; /^(?:0\|-?[1-9][0-9]{0,999})(?![\s\S])/u` | **Required.** Cardinality or budget bound for the named resource. Exceeding the bound is refused; null denotes no bound only where admitted by the schema. |
| `expression.[variant 2].[kind=integer-compare].schema.maximum` | `string; max length 1001; /^(?:0\|-?[1-9][0-9]{0,999})(?![\s\S])/u` | **Required.** Cardinality or budget bound for the named resource. Exceeding the bound is refused; null denotes no bound only where admitted by the schema. |
| `expression.[variant 2].[kind=integer-compare].schema.unit` | `closed object OR closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=integer-compare].schema.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=integer-compare].schema.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=integer-compare].schema.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=integer-compare].schema.unit.[kind=currency].kind` | `"currency"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=integer-compare].schema.unit.[kind=currency].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=integer-compare].operator` | `"eq" \| "ne" \| "lt" \| "lte" \| "gt" \| "gte"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=integer-compare].left` | `closed object OR closed object` | **Required.** Defines left for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=integer-compare].left.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=integer-compare].left.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=integer-compare].left.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=integer-compare].left.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=integer-compare].left.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=integer-compare].left.[kind=literal].value` | `string; max length 1001; /^(?:0\|-?[1-9][0-9]{0,999})(?![\s\S])/u` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 2].[kind=integer-compare].right` | `closed object OR closed object` | **Required.** Defines right for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=integer-compare].right.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=integer-compare].right.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=integer-compare].right.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=integer-compare].right.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=integer-compare].right.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=integer-compare].right.[kind=literal].value` | `string; max length 1001; /^(?:0\|-?[1-9][0-9]{0,999})(?![\s\S])/u` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 2].[kind=real-compare].kind` | `"real-compare"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=real-compare].schema` | `closed object` | **Required.** Defines schema for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].schema.kind` | `"real"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=real-compare].schema.representation` | `"binary64"` | **Required.** Defines representation for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].schema.precisionBits` | `53` | **Required.** Defines precision Bits for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].schema.minimum` | `number` | **Required.** Cardinality or budget bound for the named resource. Exceeding the bound is refused; null denotes no bound only where admitted by the schema. |
| `expression.[variant 2].[kind=real-compare].schema.maximum` | `number` | **Required.** Cardinality or budget bound for the named resource. Exceeding the bound is refused; null denotes no bound only where admitted by the schema. |
| `expression.[variant 2].[kind=real-compare].schema.tolerance` | `closed object` | **Required.** Defines tolerance for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].schema.tolerance.absolute` | `number; ≥ 0` | **Required.** Defines absolute for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].schema.tolerance.relative` | `number; ≥ 0` | **Required.** Defines relative for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].schema.unit` | `closed object OR closed object` | **Required.** Defines unit for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].schema.unit.[kind=dimensionless].kind` | `"dimensionless"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=real-compare].schema.unit.[kind=unit].kind` | `"unit"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=real-compare].schema.unit.[kind=unit].key` | `string; min length 1; max length 120; /^[a-z][a-z0-9-]*$/u` | **Required.** Stable semantic identifier used by references; changing it changes identity. |
| `expression.[variant 2].[kind=real-compare].operator` | `"approximately-equal" \| "not-approximately-equal"` | **Required.** Variant comparison or operation; its value must match the expected type. |
| `expression.[variant 2].[kind=real-compare].left` | `closed object OR closed object` | **Required.** Defines left for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].left.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=real-compare].left.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].left.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=real-compare].left.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=real-compare].left.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=real-compare].left.[kind=literal].value` | `number` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `expression.[variant 2].[kind=real-compare].right` | `closed object OR closed object` | **Required.** Defines right for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].right.[kind=field].kind` | `"field"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=real-compare].right.[kind=field].field` | `closed object` | **Required.** Defines field for this object. Observe the type, variants and bounds in the Options column. |
| `expression.[variant 2].[kind=real-compare].right.[kind=field].field.definitionPath` | `string; min length 1; max length 600; /^workspace\/[a-z0-9-]+(?:\/surface\/[a-z0-9-]+)*$/u` | **Required.** Exact path of a definition in the Model; this is not a record instance ID. |
| `expression.[variant 2].[kind=real-compare].right.[kind=field].field.fieldKey` | `string; min length 1; max length 120; /^[a-zA-Z][a-zA-Z0-9]*$/u` | **Required.** Key of a Field declared on the referenced Surface definition. |
| `expression.[variant 2].[kind=real-compare].right.[kind=literal].kind` | `"literal"` | **Required.** Selects the variant and the properties admitted in this branch. |
| `expression.[variant 2].[kind=real-compare].right.[kind=literal].value` | `number` | **Required.** Effective value interpreted according to the enclosing type and discriminant. |
| `contract` | `"WorkspaceRule@1"` | **Required.** Exact discriminant of this contract variant. Match the literal value shown. |

## Reading the contract

A path ending in `[]` describes each list item; `{key}` describes each dictionary value. The `↻` marker refers to the same recursive expression. Closed objects reject additional properties. Semantic validation denotes an additional check: matching a type does not make a reference, permission or transition valid. References must resolve in the Model and the current user context.

An older variant cannot accept properties belonging to a newer variant. The compiler checks the version and consistency of the complete Model.

## Structural example

This fragment passes the schema for this section. Its business references must be defined in the enclosing Model.

```json
{
  "key": "work-objective-present",
  "label": "Objectif du travail requis",
  "expression": {
    "kind": "present",
    "field": {
      "definitionPath": "workspace/workshop/surface/work-node",
      "fieldKey": "objective"
    }
  },
  "contract": "WorkspaceRule@1"
}
```

## Related references

[Complete Model index](https://developers.dagio.ai/reference/) · [Build a Model](https://developers.dagio.ai/models/)

<!-- surface-examples:start -->

## Applied examples : Check before confirming

One rule requires a company; another rejects a zero or negative amount.

### Configuration

Contract object `workspaceRule`. [Properties and accepted values](https://developers.dagio.ai/reference/workspace-rule/).

```json
{
  "key": "work-objective-present",
  "label": "Objectif du travail requis",
  "expression": {
    "kind": "present",
    "field": {
      "definitionPath": "workspace/workshop/surface/work-node",
      "fieldKey": "objective"
    }
  },
  "contract": "WorkspaceRule@1"
}
```

### Variation and connection

Fragment placed in `rules[]`. [Properties and accepted values](https://developers.dagio.ai/reference/workspace-model-foundation/).

```json
{
  "contract": "WorkspaceRule@1",
  "key": "positive-amount",
  "label": "Positive amount",
  "expression": {
    "kind": "compare",
    "field": {
      "definitionPath": "workspace/quotes/surface/quote",
      "fieldKey": "amount"
    },
    "operator": "gt",
    "value": 0
  }
}
```

### UI layout example

The illustrative layout below places this configuration in the Clients/Quotes app. Insert each fragment at the stated location, with Field, Query and Action references matching the Model declarations.

1. Company *
2. Status *
3. Notes
4. Create client

<!-- surface-examples:end -->
