Verdict.RuleEngine

Static type of a contract field / connector parameter / connector output.

String.

Decimal number.

Boolean.

ISO-8601 date or date-time (carried as a string in JSON).

Array.

Object.

Shared instance.

Initializes the converter.

Helpers for .

Maps a static field type to the runtime value type.

Field type.

DSL token of a field type.

Field type.

A field of the application data contract.

Dotted path (e.g. applicant.dob). Static type. Whether the field may be null or absent at runtime. Optional closed set of allowed values (strings). Optional maximum string length.

A field of the application data contract.

Dotted path (e.g. applicant.dob). Static type. Whether the field may be null or absent at runtime. Optional closed set of allowed values (strings). Optional maximum string length.

Dotted path (e.g. applicant.dob).

Static type.

Whether the field may be null or absent at runtime.

Optional closed set of allowed values (strings).

Optional maximum string length.

Versioned dictionary of contract fields supplied by the host (the host owns the Application Data Contract). Validation type-checks every field reference of a ruleset against it.

Contract id (e.g. app-contract). Contract version (≥ 1). Fields keyed by path.

Versioned dictionary of contract fields supplied by the host (the host owns the Application Data Contract). Validation type-checks every field reference of a ruleset against it.

Contract id (e.g. app-contract). Contract version (≥ 1). Fields keyed by path.

Contract id (e.g. app-contract).

Contract version (≥ 1).

Fields keyed by path.

Path of the reference id inherited by every contract.

Maximum supported length of the inherited reference id.

Mandatory field inherited by every contract.

Reference of this contract ({id}@v{version}).

Creates a contract from a list of fields.

Contract id. Version. Fields. A field is invalid, duplicated, or conflicts with a base field.

Attempts to resolve a field by exact path.

Path. Field.

Returns the fields matching an input declaration: an exact path, or a glob ending in .* (all fields under the prefix) or the bare * (all fields).

Path or glob.

Whether a field path is covered by any of the given input declarations.

Field path. Input declarations (paths or globs).

Serializes the contract to its JSON document form.

Serializes the contract canonically (for hashing / persistence).

Parses the JSON document form ({ "id", "version", "fields": [ ... ] }).

JSON text. Invalid document.

JSON document form of a contract schema.

Contract id.

Version.

Fields.

Creates the document form of a schema (fields sorted by path).

Schema.

Execution mode: production uses production connector targets; sandbox never does.

Live execution: production connector targets, trace persisted.

Test execution: recorded mocks / test targets only; may execute non-published versions.

Final outcome of a ruleset execution.

All checks passed.

At least one check failed.

Human review required.

Helpers for .

Maps a DSL outcome kind to the result outcome.

Kind.

DSL token (PASS/FAIL/FLAG).

Outcome.

An outcome node that fired during execution.

Node id. Outcome kind. Whether the outcome is hard (only meaningful for ). Stable reason code. Rendered reason text. Severity annotation.

An outcome node that fired during execution.

Node id. Outcome kind. Whether the outcome is hard (only meaningful for ). Stable reason code. Rendered reason text. Severity annotation.

Node id.

Outcome kind.

Whether the outcome is hard (only meaningful for ).

Stable reason code.

Rendered reason text.

Severity annotation.

Request to execute a ruleset.

Ruleset id.

Version to execute ( or ).

Application payload.

Execution mode.

Host correlation id, recorded with the persisted trace.

Trace redaction overrides (merged with ).

Actor recorded for sandbox test runs.

Result of a ruleset execution. Non-negotiable: is authoritative. When it is a hard FAIL outcome fired and no host, ML or downstream component may turn the decision into a pass. is never null and never empty: an execution without an explanation is a bug.

Ruleset id.

Version executed.

Final outcome (FAIL if any FAIL fired, else FLAG if any FLAG fired, else PASS).

True when any fired outcome is a hard FAIL. Must never be overridden by the host.

All outcomes that fired, in visit order.

Sum of all accumulators, or when the ruleset used none.

Complete explanation. Never null, never empty.

Wall-clock duration.

Route hints collected from routeHint nodes, in visit order.

Per-accumulator totals.

Execution mode.

Correlation id echoed from the request.

How a redacted value is represented in traces.

Replace with ***.

Replace with a SHA-256 hex digest of the canonical value.

Omit the value entirely (⟨omitted⟩).

One redaction rule.

Scope field path (e.g. applicant.dob), a glob (applicant.*), or a connector parameter selector of the form connector:{ref}:{param} (e.g. connector:conn-interpol-api@v2:passportNo; * allowed for ref or param). Strategy.

One redaction rule.

Strategy.

A set of redaction rules. Unredacted values of matched paths are never written to traces.

Rules.

A set of redaction rules. Unredacted values of matched paths are never written to traces.

Rules.

No redaction.

Concatenates two profiles (later rules take precedence).

Profile whose rules are appended.

Engine-wide options (configure via AddRuleEngine(cfg => cfg.Options...)).

Maximum subRuleset nesting depth (default 3).

Connector timeout used when a node does not specify timeoutMs (default 5 s).

Upper bound for any connector timeout, including per-node overrides (default 30 s).

Require the publishing approver to differ from the draft author (default true).

Maximum visited nodes per execution, including sub-rulesets (default 500).

Persist production traces through (default true).

Persist sandbox executions as test runs through (default true).

Redaction applied to every execution (request profiles are merged on top).

Validates option values.

An option is out of range.

The rule engine facade.

Executes a published (or, in , any non-archived) ruleset version against an input payload. Never throws for rule-level problems: evaluation errors, connector failures and budget overruns surface as outcomes with a full trace: connector failures follow the node's onErrorBehavior, while engine-level errors (evaluation error, unknown node, sub-ruleset resolution, node budget) fail the whole cycle as a hard FAIL and abort traversal.

Request. Cancellation token. The ruleset / version does not exist or is not executable in the requested mode.

Static validation of a DSL document without execution. Performs all local checks (shape, graph, scope flow, typing). Referential checks against connector and sub-ruleset stores require ; this overload reports them as skipped (RS900 warning).

Document. Contract schema the document is validated against.

Full static validation including connector and sub-ruleset referential checks.

Document. Contract schema. Cancellation token.

Thrown when a ruleset version cannot be resolved for execution.

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Selects which version of a ruleset to load: a pinned number or the latest published one.

The latest version.

Selects a specific version number.

Version (≥ 1).

A specific version number.

Version (≥ 1).

A specific version number.

Version (≥ 1).

The latest published version.

A stored ruleset version: the document plus lifecycle metadata.

Ruleset id.

Version number (≥ 1, monotonically increasing per ruleset).

Lifecycle state.

The DSL document.

SHA-256 (hex) of the canonical document, computed on save.

Contract id referenced by the document.

Contract version referenced by the document.

Free-text change notes.

Author of the draft.

Approver who published (must differ from under four-eyes).

Creation timestamp (UTC).

Last update timestamp (UTC).

Publication timestamp (UTC).

Deprecation timestamp (UTC).

Reference of this version.

Who performs a lifecycle transition and why.

User / service performing the transition (the approver for publishing). Optional notes recorded in the audit log.

Who performs a lifecycle transition and why.

User / service performing the transition (the approver for publishing). Optional notes recorded in the audit log.

User / service performing the transition (the approver for publishing).

Optional notes recorded in the audit log.

A sandbox test run persisted for audit / regression purposes.

Run id.

Ruleset id.

Version executed.

Input payload.

Serialized .

Who ran the test.

When (UTC).

A production execution trace persisted append-only.

Trace id.

Ruleset id.

Version executed.

Host correlation id.

Execution mode.

Final outcome.

Whether a hard failure fired.

Accumulated score, if any.

The trace.

Elapsed milliseconds.

When (UTC).

Persistence of rulesets, their versions, test runs and production traces. Implemented by the EF Core package.

Loads a version (pinned or latest published). Returns when not found.

Ruleset id. Version selector. Cancellation token.

Saves a document as a new version (version = max + 1) and computes its hash.

Document. Author. Cancellation token.

Performs a lifecycle transition, enforcing the state machine and (when configured) four-eyes approval: publishing requires ctx.Actor != Author. Publishing also re-runs validation and refuses on any error. Every transition writes an audit row.

Ruleset id. Version. Target state. Actor and notes. Cancellation token. Transition not allowed.

Creates a new draft version by copying the content of an existing version (the "re-publish" / rollback flow: published rows never change, a new row is published instead).

Ruleset id. Version to copy. Author of the new draft. Change notes. Cancellation token. The source version does not exist.

Replaces the document of an existing version in place. Published (and any other non-draft) versions are immutable — edit them by creating a new draft instead ().

Ruleset id (must match ). Draft version number. New document content. Who edited. Optional change notes (kept unchanged when ). Cancellation token. The version does not exist. The version is not a draft.

Deletes a version. Any other state is refused — published history is immutable; retire versions through Deprecated/Archived transitions instead. Removing the last version also removes the ruleset itself.

Ruleset id. Draft version number. Who deleted. Cancellation token. The version does not exist. The version is not a draft.

Lists all versions of a ruleset, newest first.

Ruleset id. Cancellation token.

Persists a sandbox test run.

Run. Cancellation token.

Persists a production execution trace (append-only).

Trace. Cancellation token.

Persistence of contract schemas so validation is reproducible per ruleset version.

Loads a contract version, or .

Reference. Cancellation token.

Saves (upserts) a contract version.

Schema. Cancellation token.

Severity of a validation finding.

Blocks publishing.

Informational; does not block publishing.

One validation finding.

Stable code (e.g. RS010); see Verdict.RuleEngine.Validation.ValidationCodes. Severity. Node the finding relates to, when applicable. Human-readable message.

One validation finding.

Stable code (e.g. RS010); see Verdict.RuleEngine.Validation.ValidationCodes. Severity. Node the finding relates to, when applicable. Human-readable message.

Stable code (e.g. RS010); see Verdict.RuleEngine.Validation.ValidationCodes.

Severity.

Node the finding relates to, when applicable.

Human-readable message.

Aggregated result of static validation. Validation never fails fast: all findings are returned.

All findings in discovery order.

Aggregated result of static validation. Validation never fails fast: all findings are returned.

All findings in discovery order.

An empty (valid) report.

True when there are no findings.

Error findings.

Warning findings.

Distinct codes present in the report.

Whether a finding with the given code exists.

Code.

Kind of connector.

Parameterized read-only SQL against a database.

REST API consumer.

JSON converter for (db|api).

Initializes the converter.

A typed input parameter of a connector operation.

Parameter name (referenced as @name in SQL / {name} in API templates). Static type. Whether the parameter must be mapped by every connectorCheck node.

A typed input parameter of a connector operation.

Parameter name (referenced as @name in SQL / {name} in API templates). Static type. Whether the parameter must be mapped by every connectorCheck node.

Parameter name (referenced as @name in SQL / {name} in API templates).

Static type.

Whether the parameter must be mapped by every connectorCheck node.

A declared output of a connector operation (exposed as {outputAs}.{name}).

Output name (DB: column name). Static type. Whether the output may be null.

A declared output of a connector operation (exposed as {outputAs}.{name}).

Output name (DB: column name). Static type. Whether the output may be null.

Output name (DB: column name).

Static type.

Whether the output may be null.

Base of connector operations. Polymorphic on kind (db / api).

Operation name.

Input parameters.

Declared outputs.

Operation timeout in milliseconds (optional; engine default applies).

Kind of connector this operation belongs to.

All output names exposed by this operation, including implicit ones (rowFound for DB).

Finds a parameter by name.

Name.

A single-SELECT read-only database operation.

Implicit boolean output telling whether a row was found.

The SELECT statement; may only reference parameters as @name.

Optional result cache TTL in seconds.

Authentication scheme of an API operation.

No authentication.

Static API key sent in a header.

Static bearer token.

HTTP basic.

OAuth2 client-credentials grant.

JSON converter for .

Initializes the converter.

Authentication configuration. Secret-bearing values are references (secret://name) resolved by the host's ISecretResolver.

Scheme.

Header name for (default X-Api-Key).

API key / bearer token reference.

Username (basic) or client id (OAuth2).

Password (basic) or client secret (OAuth2) reference.

Token endpoint for OAuth2 client credentials.

OAuth2 scope.

Retry policy of an API operation.

Number of retries after the first attempt. Base backoff between attempts in milliseconds.

Retry policy of an API operation.

Number of retries after the first attempt. Base backoff between attempts in milliseconds.

Number of retries after the first attempt.

Base backoff between attempts in milliseconds.

Circuit-breaker policy of an API operation.

Failures within the window that open the circuit. Sampling window in seconds. How long the circuit stays open in seconds.

Circuit-breaker policy of an API operation.

Failures within the window that open the circuit. Sampling window in seconds. How long the circuit stays open in seconds.

Failures within the window that open the circuit.

Sampling window in seconds.

How long the circuit stays open in seconds.

Maps a JSONPath-lite expression of the response body to an output.

Output name (must be declared in ). Path such as $.result.hit or $.matches[0].score.

Maps a JSONPath-lite expression of the response body to an output.

Output name (must be declared in ). Path such as $.result.hit or $.matches[0].score.

Output name (must be declared in ).

Path such as $.result.hit or $.matches[0].score.

What to do when an error mapping matches.

Treat as connector error (node error path).

Treat as a successful negative screening: outputs are the declared defaults with hit=false.

Treat as success but force a FLAG outcome on the node.

JSON converter for .

Initializes the converter.

Classifies a response as an error / negative result.

Action. Matches an HTTP status code. Matches when the JSONPath-lite expression resolves to a truthy / non-null value.

Classifies a response as an error / negative result.

Action. Matches an HTTP status code. Matches when the JSONPath-lite expression resolves to a truthy / non-null value.

Action.

Matches an HTTP status code.

Matches when the JSONPath-lite expression resolves to a truthy / non-null value.

A REST API operation.

HTTP method.

Path template relative to the target base URL, e.g. /screen?name={fullName}.

Optional JSON body template with {param} placeholders.

Authentication.

Static headers (values may reference secret://).

Retry policy.

Circuit breaker.

Response → output mappings.

Error classification rules, evaluated in order.

A connector definition: operations plus production and test targets (target JSON is kind-specific and stored as plain text — no encryption at rest; see CLAUDE.md §14 #5).

Connector id (e.g. conn-interpol-api).

Display name.

Kind.

Description.

Operations.

Production target (DB: {engine, connectionString}; API: {baseUrl, ...}). Never used in sandbox mode.

Test target used in sandbox mode when no recorded mock matches.

Finds an operation by name.

Operation name.

Serializes the definition (without targets) using the DSL JSON options.

Parses a definition.

JSON text. Invalid document.

A stored connector definition version with lifecycle metadata (same state machine as rulesets).

Connector id.

Version (≥ 1).

State.

Definition (targets in plain text — no encryption at rest).

Author.

Approver.

Created (UTC).

Updated (UTC).

Published (UTC).

Deprecated (UTC).

Reference.

A recorded request/response pair used as a sandbox mock (request identified by operation + parameter hash).

Connector id.

Connector version.

Operation name.

SHA-256 hex of the canonical parameter object (see ).

Canned outputs returned to the rule (already mapped to the output schema).

Optional human description.

Created (UTC).

Computes the parameter hash of an invocation.

Parameters.

Persistence of connector definitions and recorded exchanges. Implemented by the EF Core package.

Loads a connector version, or .

Reference. Cancellation token.

Loads the latest published version of a connector, or .

Connector id. Cancellation token.

Saves a definition as a new draft version.

Definition. Author. Cancellation token.

Replaces the definition of an existing version in place (targets are re-protected). Non-draft versions are immutable — create a new draft instead.

Connector id (must match ). Draft version number. New definition content. Who edited. Cancellation token. The version does not exist. The version is not a draft.

Deletes a version together with its recorded exchanges. Any other state is refused — retire published versions through Deprecated/Archived transitions instead. Removing the last version also removes the connector itself.

Connector id. Draft version number. Who deleted. Cancellation token. The version does not exist. The version is not a draft.

Performs a lifecycle transition (state machine + four-eyes + audit).

Connector id. Version. Target state. Actor / notes. Cancellation token.

Lists versions, newest first.

Connector id. Cancellation token.

Finds a recorded exchange for an invocation, or .

Connector reference. Operation. Parameter hash. Cancellation token.

Saves (upserts) a recorded exchange.

Exchange. Cancellation token.

Ambient information passed to a connector invocation. is authoritative for target selection.

Execution mode; must never reach a production target. Calling ruleset. Calling ruleset version. Calling node. Host correlation id. Effective timeout for the whole invocation (including retries).

Ambient information passed to a connector invocation. is authoritative for target selection.

Execution mode; must never reach a production target. Calling ruleset. Calling ruleset version. Calling node. Host correlation id. Effective timeout for the whole invocation (including retries).

Execution mode; must never reach a production target.

Calling ruleset.

Calling ruleset version.

Calling node.

Host correlation id.

Effective timeout for the whole invocation (including retries).

Outcome of a connector invocation. Failures are returned, not thrown.

Whether the invocation produced usable outputs.

Outputs mapped to the declared output schema (all-null on failure).

Status token for traces (ok, error, timeout, mock, hit-false…).

Attempts made.

Error message on failure.

Whether an mapping requested a forced flag.

Response summary for traces (redacted later).

Creates a successful result.

Outputs. Status token. Attempts.

Creates a failed result with all-null outputs.

Operation (for output schema). Error message. Status token. Attempts.

Creates an output object with every declared output set to null.

Operation.

A resolved, invocable connector bound to a target appropriate for the resolution mode.

Kind.

Invokes an operation. Implementations return failures as and only throw for programming errors.

Operation name. Parameter values (null allowed for optional parameters). Invocation context. Cancellation token.

Resolves connectors by reference, honouring the execution mode (sandbox → mocks / test target only).

Resolves a connector.

Reference (conn-x@v2). Execution mode. Cancellation token. The connector cannot be resolved (unknown, not published, no usable target).

Connector resolution / configuration failure.

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Reference to a specific connector definition version (conn-x@v2).

Connector id. Version number (≥ 1).

Reference to a specific connector definition version (conn-x@v2).

Connector id. Version number (≥ 1).

Connector id.

Version number (≥ 1).

Parses a reference or throws.

Reference text. The text is not a valid reference.

Attempts to parse a reference.

Reference text. Parsed reference.

Resolves secret references (secret://name) to plaintext values. Implemented by the host.

Resolves a secret by name.

Secret name (without the secret:// scheme). Cancellation token. The secret is unknown.

Helpers for secret:// references.

Reference scheme.

Whether a value is a secret reference.

Value.

Extracts the secret name from a reference.

Reference.

Resolves a value that may be a secret reference; plain values are returned unchanged.

Resolver. Value or reference. Cancellation token.

Secret resolver over an in-memory dictionary (tests, simple hosts).

Initializes the resolver.

Secrets by name.

Secret resolver that knows no secrets.

Shared instance.

Creates runtime connectors for a kind of definition. Implemented by the DB and API runtime packages.

Kind handled.

Creates a connector bound to the target appropriate for . Sandbox connectors must be built without ever touching .

Definition version. Execution mode. No usable target for the mode.

Sandbox wrapper: answers from recorded exchanges first (matched by operation + parameter hash), then from the test-target connector, otherwise fails. It is constructed without any reference to a production target.

Initializes the wrapper.

Store holding recorded exchanges. Connector reference. Kind. Connector bound to the test target, or when none is configured.

Whether a test target is available after recorded mocks.

Registry over a fixed set of connectors (tests, hosts with static wiring). Entries may be mode-specific.

Registers a connector for every mode.

Reference. Connector.

Registers a connector for one mode only.

Reference. Mode. Connector.

Registry backed by : loads the definition version (must be Published or Deprecated), picks the factory for its kind and caches the resulting connector per (reference, mode).

Initializes the registry.

Definition store. Factories (one per kind). Logger.

Drops cached connectors (e.g. after a definition was deprecated).

Canonical JSON writer: object properties sorted by ordinal key, no whitespace, numbers normalized (no trailing zeros, no exponent), relaxed (deterministic) escaping. Two structurally equal documents always produce byte-identical output, which makes the output suitable for hashing and storage.

Serializes a node canonically.

Node (a node is written as JSON null). Pretty-print (keys still sorted); not for hashing.

Serializes a node canonically to UTF-8 bytes.

Node. Pretty-print (keys still sorted); not for hashing.

Re-serializes arbitrary JSON text canonically.

JSON text.

Writes a node canonically to .

Writer. Node.

Extracts a decimal from a numeric regardless of whether it is backed by a parsed or by a CLR primitive (, , …). Returns when the number does not fit in a decimal.

Numeric JSON value. Decimal value.

Normalizes a decimal so that its scale carries no trailing zeros (e.g. 1.50 → 1.5, 2.0 → 2).

Value.

Formats a decimal using invariant culture with normalized scale.

Value.

Computes SHA-256 hashes of canonical JSON documents (lower-case hex).

Hashes a ruleset document by its canonical serialization.

Document.

Hashes any JSON node by its canonical serialization.

Node.

Hashes arbitrary JSON text after canonicalizing it.

JSON text.

Hashes text that is already canonical (no re-serialization).

Canonical JSON text.

Thrown when DSL JSON text cannot be parsed into a .

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Entry point for (de)serializing DSL documents with System.Text.Json.

DSL schema version emitted by this library.

Serializer options used for all DSL documents (camelCase, strict, out-of-order discriminator allowed).

Options used for pretty-printing (for display only).

Parses DSL JSON text.

JSON text. The text is not a valid document.

Parses a DSL JSON node.

JSON node. The node is not a valid document.

Serializes a document (non-canonical; property order follows the model).

Document. Pretty-print.

Converts a document to a JSON node.

Document.

Serializes a document in canonical form (sorted keys, no whitespace, normalized numbers). Use this form for hashing and persistence.

Document.

Serializes any value with the DSL options.

Value type. Value.

Traversal strategy of a ruleset (strategy document property).

Visit every reachable branch in document order and aggregate all fired outcomes (evaluate-all).

Stop at the first outcome node reached (first-match).

Outcome declared by an outcome node (PASS, FAIL, FLAG).

The check passed.

The check failed.

The check requires human review.

Severity annotation of an outcome node.

Informational.

Warning.

Critical.

Behaviour of a connectorCheck node when the connector invocation fails.

Route to onError (if present) and force a FLAG outcome with CONNECTOR_ERROR.

Route to onError (if present) and force a FAIL outcome with CONNECTOR_ERROR.

Continue on onSuccess with all-null outputs and record a trace warning.

Retry the invocation once; if it fails again behave like .

Base converter mapping an enum to an explicit set of DSL string tokens.

Enum type.

Initializes the converter with the token map.

Enum → token map.

Returns the DSL token for .

Enum value.

Attempts to parse a DSL token.

Token text. Parsed value.

JSON converter for .

Shared instance.

Initializes the converter.

JSON converter for .

Shared instance.

Initializes the converter.

JSON converter for .

Shared instance.

Initializes the converter.

JSON converter for .

Shared instance.

Initializes the converter.

Kind of an node.

{"field": "path"}.

{"lit": value}.

{"var": "name"}.

{"acc": "name"}.

{"fn": "name", "args": [...]}.

{"op": "...", ...}.

Immutable expression tree node of the DSL. Serialized by (the JSON shape is discriminated by the presence of the op/field/lit/fn/var/acc key).

Kind of this node.

Reads a value from the evaluation scope by dotted path (input payload, vars.x, connector outputs, accumulators.x).

Dotted path.

Reads a value from the evaluation scope by dotted path (input payload, vars.x, connector outputs, accumulators.x).

Dotted path.

A literal JSON value.

Initializes a literal.

JSON value (may be ).

The literal JSON value ( represents JSON null).

Reads a derived variable set by a setVariable node.

Variable name.

Reads a derived variable set by a setVariable node.

Variable name.

Reads the current value of a score accumulator.

Accumulator name.

Reads the current value of a score accumulator.

Accumulator name.

Invokes a registered function.

Initializes a function call.

Function name. Arguments.

Function name (e.g. days_until).

Arguments.

Applies an operator to its operands.

Initializes an operation.

Operator. Operands in positional order (see ).

Operator.

Operands. Binary: [left, right]; unary: [arg]; between: [value, low, high]; and/or: any number of operands.

All DSL operators.

Operand-count shape of an operator.

One operand (arg).

Two operands (left, right).

Three operands (left, low, high).

One or more operands (args).

Semantic category of an operator.

Equality / ordering.

in / not_in.

String operators.

between.

is_null / is_not_null.

and / or / not.

Arithmetic.

Static metadata about an operator.

Operator. DSL token (e.g. >=, not_in). Arity. Category.

Static metadata about an operator.

Operator. DSL token (e.g. >=, not_in). Arity. Category.

Operator.

DSL token (e.g. >=, not_in).

Arity.

Category.

All operators.

Looks up metadata by operator.

Operator.

Attempts to look up metadata by DSL token.

Token. Metadata.

(De)serializes trees. Read shapes: {"field":"a.b"} → ; a bare JSON string is accepted as a field-path shorthand. {"lit": any} → ; bare numbers, booleans, arrays and null are accepted as literal shorthand. {"var":"name"}, {"acc":"name"}, {"fn":"name","args":[...]}. {"op":"...", ...} with operands given as args, or left/right, arg, or left/low/high. Write shape is canonical: binary → left/right, unary → arg, ternary → left/low/high, variadic → args.

Converts a JSON node to an expression tree.

JSON node. The node is not a valid expression.

Converts an expression tree to its canonical JSON node shape.

Expression.

A ruleset document: the root of the JSON DSL. Immutable; deserialize with .

Stable ruleset identifier (e.g. rs-eligibility-tourist).

Human-readable name.

Reference to the application data contract, in the form {contractId}@v{version}.

Optional free-text description.

Evaluation strategy. Defaults to .

Nodes of the rule graph. Exactly one must be a .

Returns the node with the given id or .

Node id.

Returns the single start node, or if there is not exactly one.

Base type of all rule graph nodes. Polymorphic on the type discriminator.

Unique node id within the document.

The DSL type token of this node.

All outgoing edges (target node ids) of this node, in document order.

Returns the DSL type token.

Returns the outgoing edges in document order.

Single entry node; declares the input fields (paths or globs like applicant.*) the ruleset consumes.

Required input field paths or globs.

Next node id.

Boolean branch.

Boolean expression.

Node id followed when the expression evaluates to true.

Node id followed when the expression evaluates to false (or null).

Multi-branch on the invariant string form of a field value.

Field path whose value selects the case.

Case value → node id. Values are compared with ordinal (invariant) equality.

Node id followed when no case matches.

Computes a derived variable exposed as vars.{name} to downstream nodes.

Variable name.

Expression computing the value.

Next node id.

Adds a delta to a named accumulator (exposed as accumulators.{name} / {"acc":name}).

Accumulator name.

Delta expression (a literal number or any numeric expression).

Next node id.

Invokes a connector operation and exposes its outputs as {outputAs}.{field}.

Connector reference in the form conn-x@v2.

Operation name declared by the connector.

Parameter name → expression (a bare string in JSON is a field path shorthand).

Scope name under which the outputs are exposed.

Node id followed on success.

Node id(s) followed on error (optional; when absent the error behaviour terminates the path).

Error behaviour.

Per-node timeout in milliseconds (capped by the global option).

Executes a published sub-ruleset and exposes its result as {outputAs}.{outcome|hardFail|score}.

Ruleset reference in the form rs-y@v3.

Optional mapping of target input path → expression. When absent the full input is forwarded.

Scope name under which the sub-result is exposed.

Next node id.

Annotation collected into the execution result metadata.

Hint text.

Next node id.

Terminal node producing an outcome.

Outcome kind.

When together with , the failure is hard: the host (or any ML layer) must never override it.

Stable reason code (e.g. PASSPORT_VALIDITY).

Human-readable reason; supports {expression} interpolation.

Optional severity.

DSL node type tokens.

start.

condition.

switch.

setVariable.

score.

connectorCheck.

subRuleset.

routeHint.

outcome.

All node type tokens.

Target(s) of an edge. In JSON either a single node id ("next": "n1") or an array of ids ("next": ["a", "b"]) for parallel branches. Under first-match parallel branches are followed in order until the first outcome fires; under evaluate-all every branch is visited in document order.

Creates targets.

One or more node ids. Empty list or empty id.

Creates a single target.

Node id.

Whether there is exactly one target.

The single target id (throws when there are several).

Implicit conversion from a single id.

Node id.

Creates targets from a single id.

Node id.

Reads a string or an array of strings; writes a string for a single target and an array otherwise.

Parser for versioned references of the form {id}@v{version} (e.g. conn-x@v2, rs-y@v3).

Attempts to parse a reference.

Reference text. Parsed id. Parsed version.

Formats a reference.

Id. Version.

Reference to a specific ruleset version (rs-y@v3).

Ruleset id. Version number (≥ 1).

Reference to a specific ruleset version (rs-y@v3).

Ruleset id. Version number (≥ 1).

Ruleset id.

Version number (≥ 1).

Parses a reference or throws.

Reference text. The text is not a valid reference.

Attempts to parse a reference.

Reference text. Parsed reference.

Reference to an application data contract version (app-contract@v2).

Contract id. Version number (≥ 1).

Reference to an application data contract version (app-contract@v2).

Contract id. Version number (≥ 1).

Contract id.

Version number (≥ 1).

Parses a reference or throws.

Reference text. The text is not a valid reference.

Attempts to parse a reference.

Reference text. Parsed reference.

Default : loads the requested version, enforces mode/state rules, runs the , asserts the trace invariant and persists traces / test runs.

Initializes the engine.

Ruleset store. Contract store. Connector definition store (for validation). Executor. Validator. Options. Time source. Logger.

Production may execute versions, or ones when pinned explicitly. Sandbox may execute anything that is not .

State. Mode. How the version was selected.

Serializes a result with the engine JSON conventions (camelCase, string enums).

Result.

Complete, ordered explanation of one ruleset execution. This exact shape is the golden-file contract: changing it changes what hosts and auditors see.

One step per visited node, in visit order. Non-fatal issues (template failures, connector fall-backs, redaction notes…).

Complete, ordered explanation of one ruleset execution. This exact shape is the golden-file contract: changing it changes what hosts and auditors see.

One step per visited node, in visit order. Non-fatal issues (template failures, connector fall-backs, redaction notes…).

One step per visited node, in visit order.

Non-fatal issues (template failures, connector fall-backs, redaction notes…).

Exact root and invoked child graphs captured at execution, or null for legacy/low-level traces without capture.

An execution-time graph copy, never reconstructed from a subsequently edited version.

Decision identifier. Version executed. Trace node prefix (empty for root, e.g. child-step/ for a nested invocation). Hash of the captured canonical document. Complete DSL graph, including branches that did not execute; contains no execution input. Exact contract used for input validation, when available.

An execution-time graph copy, never reconstructed from a subsequently edited version.

Decision identifier.

Version executed.

Trace node prefix (empty for root, e.g. child-step/ for a nested invocation).

Hash of the captured canonical document.

Complete DSL graph, including branches that did not execute; contains no execution input.

Exact contract used for input validation, when available.

One visited node.

Node id. DSL node type token. Canonical text of what the node evaluated (e.g. days_until(passport.expiryDate) >= 180). The same with values substituted (e.g. days_until(2027-11-02)=429 >= 180). Machine-readable operand values (redacted per profile). Result of a boolean node (condition), when applicable. Connector invocation details for connectorCheck nodes. Wall-clock time spent on the node. Declaration order is the serialized property order (part of the golden-file contract). Nullable members carry defaults so that a stored trace — written with nulls omitted — deserializes again.

One visited node.

Node id.

DSL node type token.

Canonical text of what the node evaluated (e.g. days_until(passport.expiryDate) >= 180).

The same with values substituted (e.g. days_until(2027-11-02)=429 >= 180).

Machine-readable operand values (redacted per profile).

Result of a boolean node (condition), when applicable.

Connector invocation details for connectorCheck nodes.

Wall-clock time spent on the node.

Connector invocation details recorded in a trace step. Request and response are redacted per profile.

Connector reference (conn-x@v2). Operation name. Parameters sent (redacted). Outputs / response summary (redacted). Status token: ok, error, timeout, mock, skipped… Total time including retries. Number of attempts made. Error message when the invocation failed. pins the serialized order (part of the golden-file contract) while the nullable members sit last in the constructor so they can carry defaults for deserialization.

Connector invocation details recorded in a trace step. Request and response are redacted per profile.

Connector reference (conn-x@v2).

Operation name.

Parameters sent (redacted).

Status token: ok, error, timeout, mock, skipped…

Total time including retries.

Number of attempts made.

Outputs / response summary (redacted).

Error message when the invocation failed.

Raised when an expression cannot be evaluated (type mismatch, division by zero, invalid regex, unknown function…). The executor maps it to the node error path and a FLAG outcome with EVALUATION_ERROR; it never escapes IRuleEngine.ExecuteAsync.

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Redacts field values before they are written to traces (see RedactionProfile).

Returns the value to expose in traces for a field path (the original value when the path is not redacted).

Scope path (e.g. applicant.dob). Original value.

Returns the value to expose in traces for a connector parameter.

Connector reference text. Parameter name. Original value.

Redactor that exposes every value unchanged.

Shared instance.

Mutable evaluation scope of one ruleset execution: input payload, derived variables (vars.*), connector / sub-ruleset outputs ({outputAs}.*) and score accumulators (accumulators.*). Not thread-safe; one instance per execution.

Path prefix of derived variables.

Path prefix of accumulators.

Initializes a scope over an input payload.

Application payload.

Input payload.

Derived variables.

Connector / sub-ruleset outputs by outputAs name.

Accumulators (insertion order preserved).

Sets (or overwrites) a derived variable.

Name. Value.

Returns a variable or .

Name.

Registers an output object under an outputAs name.

Name. Output object.

Adds a delta to an accumulator (created at 0) and returns the new total.

Accumulator name. Delta.

Returns the accumulator value (0 when not yet touched).

Accumulator name.

Sum of all accumulators, or when none were used.

Resolves a dotted path. Resolution order of the first segment: vars, accumulators, a registered output name, then the input payload. Missing values resolve to (never throw).

Dotted path.

Walks a JSON tree by path segments (object properties or array indices).

Root node. Segments.

An expression annotated with its evaluated value and evaluated children (used to render resolved trace text).

The expression. Evaluated value ( when is false). Resolved operands / arguments (in positional order). False when the operand was skipped by short-circuit evaluation.

An expression annotated with its evaluated value and evaluated children (used to render resolved trace text).

The expression. Evaluated value ( when is false). Resolved operands / arguments (in positional order). False when the operand was skipped by short-circuit evaluation.

The expression.

Evaluated value ( when is false).

Resolved operands / arguments (in positional order).

False when the operand was skipped by short-circuit evaluation.

Deterministic expression evaluator. Pure function of (expression, scope, time provider, function registry). All failures surface as ; no other exception type escapes for well-formed input. Thread-safe; one instance can serve concurrent executions.

Regex match timeout (spec: 100 ms).

Initializes the evaluator.

Function registry (defaults to built-ins). Time source (defaults to ).

Function registry in use.

Time provider in use.

Evaluates an expression and returns only its value.

Expression. Scope. Evaluation failed.

Evaluates an expression as a boolean condition: only a boolean true is truthy; null is false.

Expression. Scope. Evaluation failed or the result is not boolean/null.

Evaluates an expression and returns the fully resolved tree.

Expression. Scope. Evaluation failed.

Whether a value counts as a satisfied condition: exactly boolean true.

Value. The value is neither boolean nor null.

When the counterpart is a date and this operand is an ISO date string, record the interpreted date in the resolved tree.

Comparison semantics: any null operand → false; otherwise operands must be type-compatible.

Compiles (and caches) a DSL regex with the mandated options; throws / for invalid patterns.

Pattern.

Canonical, stable, human-readable printer for expressions — the heart of explainability. renders the expression itself, e.g. days_until(passport.expiryDate) >= 180. renders the same shape with values substituted, e.g. days_until(2027-11-02)=429 >= 180. produces the machine-readable operand map.

Renders the canonical text of an expression.

Expression.

Renders the resolved text of an evaluated expression (values substituted, functions and arithmetic annotated with =value).

Resolved expression. Optional redactor applied to field values.

Collects the machine-readable operand values of an evaluated expression: field paths, vars.*, accumulators.*, function calls and arithmetic sub-expressions (keyed by canonical text). Literals are omitted.

Resolved expression. Optional redactor applied to field values.

Returns the display token of an operator.

Operator.

Static signature of an expression function, used by the evaluator (arity) and the type checker.

Function name as used in the DSL. Minimum argument count. Maximum argument count, or -1 for variadic. Accepted types per position ( entry = any). For variadic functions the last entry repeats. Static return type, or when it depends on the arguments.

Static signature of an expression function, used by the evaluator (arity) and the type checker.

Function name as used in the DSL.

Minimum argument count.

Maximum argument count, or -1 for variadic.

Accepted types per position ( entry = any). For variadic functions the last entry repeats.

Static return type, or when it depends on the arguments.

Whether the function accepts an unbounded number of arguments.

Returns the accepted types for a positional argument ( = any).

Argument index.

Ambient context passed to functions.

Initializes the context.

Time source (never use directly).

Time source.

Current UTC time.

Current UTC date.

A function callable from expressions via {"fn": name, "args": [...]}. Implementations must be pure and thread-safe.

Signature.

Invokes the function. Argument count is validated by the evaluator beforehand.

Evaluated arguments. Ambient context. Invalid argument types or values.

Convenience implementation of over a delegate.

Initializes the function.

Signature. Body.

Immutable, thread-safe registry of expression functions. Extend with .

Initializes a registry from a set of functions (later entries override earlier ones with the same name).

Functions.

Registry containing only the built-in functions.

All registered function names.

All registered functions.

Attempts to resolve a function by name.

Name. Function.

Returns a new registry with additional (or overriding) functions.

Functions to add.

The built-in function set.

age(date): whole years elapsed since the date, as of today (UTC).

days_until(date): calendar days from today (UTC) until the date (negative when past).

days_since(date): calendar days from the date until today (UTC) (negative when future).

now(): current UTC date-time from the injected .

len(x): string length or array count.

lower(s).

upper(s).

trim(s).

coalesce(a, b, ...): first non-null argument.

round(n, d?): rounds half away from zero to d decimals (default 0).

abs(n).

min(...): smallest non-null number (null when all are null).

max(...): largest non-null number (null when all are null).

All built-ins.

Runtime type of a .

JSON null / missing.

String.

Decimal number.

Boolean.

Date or date-time (UTC).

Array.

Object.

Immutable runtime value of the expression evaluator. Numbers are always ; dates are in UTC. Conversion from JSON is lossless and never guesses (a JSON string stays a string even when it looks like a date; date-typed functions and comparisons parse on demand with invariant culture).

The singleton null value.

Boolean true.

Boolean false.

Runtime type.

Whether this is the null value.

Creates a string value.

Value.

Creates a number value.

Value.

Creates a number value.

Value.

Creates a boolean value.

Value.

Creates a date value (normalized to UTC).

Value.

Creates an array value.

Items.

Converts a JSON node to a runtime value. Never throws for valid JSON.

Node.

Converts the value back to a JSON node (dates become ISO-8601 strings).

Formats the value for human-readable trace text (strings quoted, dates ISO, numbers invariant).

Attempts to interpret the value as a date: dates pass through, strings are parsed with invariant culture.

Parsed date.

Parses an ISO-8601 date (yyyy-MM-dd) or date-time (round-trip) string; the result is UTC.

Text. Parsed date.

Formats a date: yyyy-MM-dd when at midnight UTC, otherwise ISO-8601 with Z.

Date (UTC).

Invariant string form used by switch nodes to match case labels.

JSON null.

String value.

Value.

String value.

Value.

Decimal number value.

Value.

Decimal number value.

Value.

Boolean value.

Value.

Boolean value.

Value.

Date/date-time value in UTC.

Value.

Date/date-time value in UTC.

Value.

Array value.

Initializes an array value.

Items.

Object value (opaque JSON object).

Initializes an object value.

JSON object.

Underlying JSON object.

Result of rendering a reason-text template.

Rendered text. Warnings produced for placeholders that could not be resolved.

Result of rendering a reason-text template.

Rendered text. Warnings produced for placeholders that could not be resolved.

Rendered text.

Warnings produced for placeholders that could not be resolved.

Renders reasonText templates with {expression} interpolation, e.g. "Passport expires in {days_until(passport.expiryDate)} days". Placeholders accept the text expression grammar of . A failing placeholder renders as ⟨unavailable⟩ and produces a warning; rendering never throws. {{ and }} render literal braces.

Marker rendered for a placeholder that failed to evaluate.

Initializes the renderer.

Evaluator used for placeholders.

Renders a template.

Template text ( renders as empty). Scope. Optional redactor applied to field placeholders.

Formats a value for inclusion in prose: strings unquoted, numbers invariant, dates ISO, null → null.

Value.

Parses the compact text expression grammar used inside templates: path.to.field, vars.x, accumulators.x, fn(arg, ...), numbers, 'strings'/"strings", true/false/null. Produces the same tree as the JSON form.

Parses text into an expression.

Expression text. The text is not a valid template expression.

Applies a to trace values. Later rules take precedence over earlier ones. Field rules match scope paths exactly, by glob (applicant.*) or *; connector rules use the form connector:{ref}:{param} where {ref} and {param} may be *.

Replacement text for .

Initializes the redactor.

Profile.

Creates a redactor for a profile, returning when the profile is empty.

Profile.

Whether a rule path matches a scope path.

Rule path (exact, prefix.* or *). Scope path.

Applies a strategy to a value (null stays null: it carries no information).

Strategy. Value.

Resolves sub-ruleset documents for subRuleset nodes, honouring the execution mode.

Returns the version record, or when it does not exist or is not executable in .

Reference. Execution mode. Cancellation token.

Resolver that knows no sub-rulesets.

Shared instance.

Everything the executor needs for one run.

Document to execute.

Version number reported in the result.

Input payload.

Execution mode.

Correlation id.

Redaction profile.

Sub-ruleset resolver.

Root input contract, if this low-level plan provides one. The engine facade always supplies it.

Contract lookup for validating mapped child inputs. Supplied by the engine facade.

Capture complete root and invoked child graphs. Enabled by the engine facade; optional for low-level callers.

Reason codes produced by the engine itself (as opposed to outcome nodes).

An expression failed to evaluate (type error, division by zero…).

The node budget was exhausted.

A connector invocation failed.

A connector error mapping requested a forced flag.

A sub-ruleset could not be resolved.

A sub-ruleset hard-failed; the failure propagates.

Sub-ruleset nesting exceeded the configured depth.

An edge pointed to a node that does not exist.

Execution finished without any outcome firing.

Deterministic rule-graph executor. Pure function of (document, input, connector results, time provider): the same inputs and connector responses always produce the same result and trace. Never throws for rule-level problems; every failure becomes a FLAG outcome with an explanatory trace step. Thread-safe; one instance serves concurrent executions.

Initializes the executor.

Expression evaluator (carries the time provider and function registry). Connector registry (a registry that rejects every resolution when null). Options. Logger.

Executes a plan.

Plan. Cancellation token (cancellation is the only exception that escapes).

Aggregates fired outcomes: FAIL if any FAIL, else FLAG if any FLAG, else PASS; hard-fail when any hard FAIL fired.

Fired outcomes.

State shared by a run and every nested sub-ruleset run: the node budget and the abort flag. Any engine-level error (evaluation error, unknown node, sub-ruleset resolution, budget) aborts the whole cycle as a hard FAIL.

A connector request value is redacted by the connector-parameter rules and, because it usually is a field value, by the field rules as well: a plain field reference inherits its field's redaction; a value derived from any redacted field is masked outright.

Engine-level errors fail the whole cycle: a hard FAIL outcome fires, and no further node — in this run, in any parallel branch, or in a parent run — is evaluated. The engine never silently passes and never throws.

Structural analysis of a rule graph.

Nodes by id (first occurrence wins on duplicates).

The single start node, or when there is not exactly one.

Ids reachable from start.

Whether a cycle exists in the reachable subgraph.

Reachable nodes in topological order (empty when a cycle exists or there is no start).

Predecessor ids per node (only edges whose target exists).

Whether the graph is structurally sound (exactly one start, no dangling edges, no cycle).

Structural checks: single start, unique ids, dangling references, reachability, cycles, termination.

Analyzes a document, appending findings.

Document. Findings sink.

A payload error, without the supplied value (which may be sensitive).

Stable error code. Exact contract field path. Actionable explanation.

A payload error, without the supplied value (which may be sensitive).

Stable error code. Exact contract field path. Actionable explanation.

Stable error code.

Exact contract field path.

Actionable explanation.

Execution was rejected before traversing a decision because its input contract was not satisfied.

Initializes an input validation failure.

Contract checked.

All input findings; values are never included.

Checks actual nested JSON against every declared contract field, without coercing or modifying input.

Returns all required, shape, type, date, and closed-value-set violations. Undeclared extra fields are allowed.

Throws when the payload does not satisfy the contract.

Pre-resolved referential data for validation: connector versions, sub-ruleset versions (recursively) and their contracts. Build with or supply manually in tests.

Context that performs local checks only (referential checks are reported as skipped).

Whether referential checks are performed.

Resolved connector versions (absent key = not found).

Resolved sub-ruleset versions, including nested ones (absent key = not found).

Resolved contracts of sub-rulesets (absent key = not found).

Static validator (§7). Returns every finding it can discover — never fails fast. Structural problems are reported first; scope-flow and typing still run over whatever structure is usable.

Initializes the validator.

Function registry (defaults to built-ins). Engine options (depth limit).

Validates a document against a contract using a pre-resolved context (or local checks only when is null).

Document. Contract. Referential context.

Resolves connectors, sub-rulesets and contracts from the stores, then validates fully.

Document. Contract. Connector store. Ruleset store. Contract store. Cancellation token.

Resolves everything a full validation needs (sub-rulesets are followed up to + 1 levels).

Root document. Connector store. Ruleset store. Contract store. Maximum sub-ruleset depth. Cancellation token.

Definitely-defined scope entering a node.

Statically inferred type of an expression.

Runtime type, or when unknown (any). Whether the value may be null at runtime. For string literals: whether the text parses as an ISO date (so it may be compared with dates). Closed value set from the contract, when known.

Statically inferred type of an expression.

Runtime type, or when unknown (any).

Whether the value may be null at runtime.

For string literals: whether the text parses as an ISO date (so it may be compared with dates).

Closed value set from the contract, when known.

Unknown / any type.

The JSON null literal.

Creates a known type.

Type. Nullable.

Creates a type from a contract field type.

Field type. Nullable. Allowed values.

Whether the type is known.

Whether this is the null literal.

Whether the value can participate in date comparisons (a date, or a date-like string literal).

Human-readable description.

Result of resolving a scope path during validation.

Whether the path resolved. Resolved type. Validation code when not found. Message when not found.

Result of resolving a scope path during validation.

Whether the path resolved. Resolved type. Validation code when not found. Message when not found.

Whether the path resolved.

Resolved type.

Validation code when not found.

Message when not found.

Success.

Type.

Failure.

Code. Message.

Resolves the static type of a scope path (contract fields, variables, connector outputs).

Resolves a dotted path.

Path.

Static type checker for expression trees. Mirrors the runtime semantics of : whatever the evaluator would reject with a type error is reported here as RS030-series findings.

Initializes the checker.

Function registry (defaults to built-ins).

Checks an expression, appending findings, and returns its inferred type.

Expression. Scope resolver. Node id for findings. Findings sink.

Whether a value of the inferred type may be passed where is declared.

Inferred type. Declared type.

Infers the static type of a JSON literal.

Literal.

Stable validation codes. Errors block publishing; warnings do not.

Document shape problem (empty id, unparsable contract reference…).

Not exactly one start node.

Duplicate node id.

Edge references a node id that does not exist.

Node is not reachable from start.

The graph contains a cycle.

A path ends in a node that is not an outcome.

Field / variable reference does not exist in the contract or the scope reaching the node.

start.inputs entry matches no contract field.

Operator applied to incompatible operand types.

Right operand of in/not_in is not an array.

Unknown function.

Wrong number of function arguments.

Function argument has an incompatible type.

Regex pattern does not compile (or is unsupported by the non-backtracking engine).

condition.expr is not boolean.

score.delta is not numeric.

switch.field is not a scalar.

connectorRef is not of the form id@vN.

Connector version does not exist.

Connector version is not published.

Operation does not exist on the connector.

Required connector parameter is not mapped.

Mapped parameter has an incompatible type.

inputMap maps a parameter the operation does not declare.

Reference to an output field the connector / sub-ruleset does not declare.

rulesetRef is not of the form id@vN.

Sub-ruleset version does not exist.

Sub-ruleset version is not published.

Composition depth exceeds MaxSubRulesetDepth.

Sub-ruleset composition is recursive.

Sub-ruleset input mapping does not match the target contract.

setVariable never referenced.

switch case value can never match (not in the field's allowed values).

hard=true on a non-FAIL outcome has no effect.

Comparison relies on a runtime coercion (e.g. date vs. string field).

onError is declared but never taken for the configured onErrorBehavior.

outputAs / variable name shadows a contract root.

A reasonText placeholder cannot be parsed or type-checked (renders as unavailable at runtime).

Literal compared against a field with a closed set of allowed values is not one of them.

Connector or sub-ruleset version is deprecated.

Field is used but not declared in start.inputs.

Referential checks (connectors, sub-rulesets) were skipped because no resolver context was supplied.

All codes with descriptions.

Description of a code.

Code.

Thrown when a published (or later) version's content is modified: published versions are immutable.

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Thrown when an append-only table (execution traces, audit log) receives an update or delete.

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Thrown when the publishing approver is the draft author while four-eyes approval is required.

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Thrown when a transition to Validated/Published is refused because static validation reported errors.

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Initializes the exception with the report.

Validation report.

The report.

Thrown when a concurrent writer changed the same version row (optimistic concurrency).

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Lifecycle state of a ruleset version (also used by connector definition versions, whose state machine is identical). Versions in or later states are immutable.

Editable working copy.

Passed static validation; still editable (editing returns it to ).

Live and immutable.

Superseded; still resolvable by pinned version but not as "latest published".

Retired; not resolvable for execution.

Thrown when an invalid lifecycle transition is requested.

Initializes the exception.

Message.

Initializes the exception.

Message. Inner exception.

Initializes the exception for a specific transition.

Source state. Target state.

Source state.

Target state.

The lifecycle state machine: Draft → Validated → Published → Deprecated → Archived, plus Validated → Draft (edit after validation) and Draft → Archived (discard). Re-publishing content is never a transition: it creates a new version row.

Allowed target states from a given state.

Source state.

Whether a transition is allowed.

Source state. Target state.

Throws when the transition is not allowed.

Source state. Target state. Transition not allowed.

Whether a version in this state is immutable (content may no longer change).

State.

Whether a version in this state can be executed in production ( or when pinned).

State.