@epilot/sdk 2.19.3 → 2.19.5

package/definitions/validation-rules.json

@@ -0,0 +1,2365 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Validation Rules API",
+    "version": "1.0.0",
+    "description": "The Validation Rules API manages reusable input validation rules for epilot journeys and entity attributes.\n\nValidation rules define constraints for user input (e.g. regex patterns, numeric ranges, character counts) that can be applied to journey blocks or entity schema attributes.\n\nKey capabilities:\n- Define validation rules using regex patterns, character patterns, or numeric constraints\n- Apply rules to journey blocks or entity schema attributes via the `used_by` association\n- Manage the lifecycle of rules (create, read, update, delete)\n- Compose complex validation logic using AND/OR/NOT condition combinators\n\n## Rule schema versions\n\nThe `rule` property holds one of two shapes, identified by the document's `_schema_version`:\n- `v1`: a json-rules-engine condition tree (regex/pattern/numeric) with static comparison values only.\n- `v2`: a declarative rule with predefined comparison operators whose comparison values may be static,\n  dynamic (a path into runtime context declared via `contexts`,\n  e.g. `contract.installment_amount`) or relative dates. v2 shapes carry an `input_type` property.\nConverting a rule between schema versions is not supported.\n"
+  },
+  "tags": [
+    {
+      "name": "Validation Rules",
+      "description": "CRUD endpoints for managing validation rules within an organization.\nAll endpoints require an epilot bearer token and operate within the authenticated organization's scope.\nRules are identified by a unique `ruleId` and can be referenced by journey blocks or entity attributes via the `used_by` field.\n"
+    }
+  ],
+  "security": [
+    {
+      "EpilotAuth": []
+    }
+  ],
+  "paths": {
+    "/v1/validation-rules": {
+      "get": {
+        "operationId": "getValidationRules",
+        "summary": "getValidationRules",
+        "description": "Returns all validation rules belonging to the authenticated user's organization.\n\nResults are returned as a flat list. Use this endpoint to list available rules when configuring journeys or entity schemas.\n",
+        "tags": [
+          "Validation Rules"
+        ],
+        "security": [
+          {
+            "EpilotAuth": []
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/GetValidationRulesResponse"
+                },
+                "example": {
+                  "results": [
+                    {
+                      "_id": "rule-abc123",
+                      "_organization_id": "728224",
+                      "_schema_version": "1.0",
+                      "title": "German postal code",
+                      "created_at": "2024-01-10T08:00:00.000Z",
+                      "updated_at": "2024-01-10T08:00:00.000Z",
+                      "created_by": "user-1",
+                      "updated_by": "user-1",
+                      "rule": {
+                        "type": "regex",
+                        "conditions": {
+                          "all": [
+                            {
+                              "fact": "inputValue",
+                              "operator": "regexMatch",
+                              "value": "^[0-9]{5}$"
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request - Invalid request body",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request body"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Unauthorized - Authentication required",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unauthorized"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Forbidden - Insufficient permissions",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unknown API Error"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "operationId": "createValidationRule",
+        "summary": "createValidationRule",
+        "description": "Creates a new validation rule for the authenticated organization.",
+        "tags": [
+          "Validation Rules"
+        ],
+        "security": [
+          {
+            "EpilotAuth": []
+          }
+        ],
+        "requestBody": {
+          "description": "Validation rule to create",
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateValidationRuleRequest"
+              },
+              "example": {
+                "title": "German postal code",
+                "rule": {
+                  "type": "regex",
+                  "conditions": {
+                    "all": [
+                      {
+                        "fact": "inputValue",
+                        "operator": "regexMatch",
+                        "value": "^[0-9]{5}$",
+                        "params": {
+                          "errorMessage": "Must be a 5-digit German postal code"
+                        }
+                      }
+                    ]
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "201": {
+            "description": "Validation rule created successfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                },
+                "example": {
+                  "_id": "rule-abc123",
+                  "_organization_id": "728224",
+                  "_schema_version": "1.0",
+                  "title": "German postal code",
+                  "created_at": "2024-01-10T08:00:00.000Z",
+                  "updated_at": "2024-01-10T08:00:00.000Z",
+                  "created_by": "user-1",
+                  "updated_by": "user-1",
+                  "rule": {
+                    "type": "regex",
+                    "conditions": {
+                      "all": [
+                        {
+                          "fact": "inputValue",
+                          "operator": "regexMatch",
+                          "value": "^[0-9]{5}$"
+                        }
+                      ]
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request - Invalid request body",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request body"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Unauthorized - Authentication required",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unauthorized"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Forbidden - Insufficient permissions",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unknown API Error"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/validation-rules/{ruleId}": {
+      "get": {
+        "operationId": "getValidationRuleById",
+        "summary": "getValidationRuleById",
+        "description": "Retrieves a specific validation rule by its unique ID.",
+        "tags": [
+          "Validation Rules"
+        ],
+        "security": [
+          {
+            "EpilotAuth": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "ruleId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "The unique identifier of the validation rule to retrieve.",
+            "example": "rule-abc123"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Validation rule retrieved successfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                },
+                "example": {
+                  "_id": "rule-abc123",
+                  "_organization_id": "728224",
+                  "_schema_version": "1.0",
+                  "title": "German postal code",
+                  "created_at": "2024-01-10T08:00:00.000Z",
+                  "updated_at": "2024-01-10T08:00:00.000Z",
+                  "created_by": "user-1",
+                  "updated_by": "user-1",
+                  "rule": {
+                    "type": "regex",
+                    "conditions": {
+                      "all": [
+                        {
+                          "fact": "inputValue",
+                          "operator": "regexMatch",
+                          "value": "^[0-9]{5}$"
+                        }
+                      ]
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Unauthorized - Authentication required",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unauthorized"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Forbidden - Insufficient permissions",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Validation rule not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Validation rule not found"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unknown API Error"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "patch": {
+        "operationId": "updateValidationRule",
+        "summary": "updateValidationRule",
+        "description": "Partially updates an existing validation rule by ID. Only the fields provided in the request body are updated.",
+        "tags": [
+          "Validation Rules"
+        ],
+        "security": [
+          {
+            "EpilotAuth": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "ruleId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "The unique identifier of the validation rule to update.",
+            "example": "rule-abc123"
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateValidationRuleRequest"
+              },
+              "example": {
+                "title": "Updated German postal code",
+                "rule": {
+                  "type": "regex",
+                  "conditions": {
+                    "all": [
+                      {
+                        "fact": "inputValue",
+                        "operator": "regexMatch",
+                        "value": "^[0-9]{5}$",
+                        "params": {
+                          "errorMessage": "Must be a valid 5-digit German postal code"
+                        }
+                      }
+                    ]
+                  }
+                }
+              }
+            }
+          },
+          "description": "Fields to update in the validation rule"
+        },
+        "responses": {
+          "200": {
+            "description": "Validation rule updated successfully",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                },
+                "example": {
+                  "_id": "rule-abc123",
+                  "_organization_id": "728224",
+                  "_schema_version": "1.0",
+                  "title": "Updated German postal code",
+                  "created_at": "2024-01-10T08:00:00.000Z",
+                  "updated_at": "2024-01-20T11:00:00.000Z",
+                  "created_by": "user-1",
+                  "updated_by": "user-2",
+                  "rule": {
+                    "type": "regex",
+                    "conditions": {
+                      "all": [
+                        {
+                          "fact": "inputValue",
+                          "operator": "regexMatch",
+                          "value": "^[0-9]{5}$"
+                        }
+                      ]
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request - Invalid request body",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request body"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Unauthorized - Authentication required",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unauthorized"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Forbidden - Insufficient permissions",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Validation rule not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Validation rule not found"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unknown API Error"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "operationId": "deleteValidationRule",
+        "summary": "deleteValidationRule",
+        "description": "Permanently deletes a validation rule by ID. Any journeys or entity attributes referencing this rule should be updated before deletion.",
+        "tags": [
+          "Validation Rules"
+        ],
+        "security": [
+          {
+            "EpilotAuth": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "ruleId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "The unique identifier of the validation rule to delete.",
+            "example": "rule-abc123"
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "Validation rule deleted successfully"
+          },
+          "401": {
+            "description": "Unauthorized - Authentication required",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unauthorized"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Forbidden - Insufficient permissions",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Validation rule not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Validation rule not found"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unknown API Error"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/validation-rules/{ruleId}/used-by": {
+      "post": {
+        "operationId": "addUsedByReference",
+        "summary": "addUsedByReference",
+        "description": "Adds a single `used_by` reference to an existing validation rule.\n\nUse this endpoint when attaching a validation rule to a journey block or entity attribute to track where the rule is applied.\n",
+        "tags": [
+          "Validation Rules"
+        ],
+        "security": [
+          {
+            "EpilotAuth": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "ruleId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "The unique identifier of the validation rule to update.",
+            "example": "rule-abc123"
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UsedBy"
+              },
+              "example": {
+                "type": "journey",
+                "source_id": "journey-xyz789"
+              }
+            }
+          },
+          "description": "The used_by reference to add"
+        },
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                },
+                "example": {
+                  "_id": "rule-abc123",
+                  "_organization_id": "728224",
+                  "_schema_version": "1.0",
+                  "title": "German postal code",
+                  "created_at": "2024-01-10T08:00:00.000Z",
+                  "updated_at": "2024-01-20T11:00:00.000Z",
+                  "created_by": "user-1",
+                  "updated_by": "user-1",
+                  "rule": {
+                    "type": "regex",
+                    "conditions": {
+                      "all": [
+                        {
+                          "fact": "inputValue",
+                          "operator": "regexMatch",
+                          "value": "^[0-9]{5}$"
+                        }
+                      ]
+                    }
+                  },
+                  "used_by": [
+                    {
+                      "type": "journey",
+                      "source_id": "journey-xyz789"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request - Invalid request body",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request body"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Unauthorized - Authentication required",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unauthorized"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Forbidden - Insufficient permissions",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Validation rule not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Validation rule not found"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unknown API Error"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "operationId": "removeUsedByReference",
+        "summary": "removeUsedByReference",
+        "description": "Removes a specific `used_by` reference from an existing validation rule.\n\nUse this endpoint when detaching a validation rule from a journey block or entity attribute.\n",
+        "tags": [
+          "Validation Rules"
+        ],
+        "security": [
+          {
+            "EpilotAuth": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "ruleId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string"
+            },
+            "description": "The unique identifier of the validation rule to update.",
+            "example": "rule-abc123"
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UsedBy"
+              },
+              "example": {
+                "type": "journey",
+                "source_id": "journey-xyz789"
+              }
+            }
+          },
+          "description": "The used_by reference to remove"
+        },
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                },
+                "example": {
+                  "_id": "rule-abc123",
+                  "_organization_id": "728224",
+                  "_schema_version": "1.0",
+                  "title": "German postal code",
+                  "created_at": "2024-01-10T08:00:00.000Z",
+                  "updated_at": "2024-01-20T11:00:00.000Z",
+                  "created_by": "user-1",
+                  "updated_by": "user-1",
+                  "rule": {
+                    "type": "regex",
+                    "conditions": {
+                      "all": [
+                        {
+                          "fact": "inputValue",
+                          "operator": "regexMatch",
+                          "value": "^[0-9]{5}$"
+                        }
+                      ]
+                    }
+                  },
+                  "used_by": []
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request - Invalid request body",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request body"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "Unauthorized - Authentication required",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unauthorized"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "403": {
+            "description": "Forbidden - Insufficient permissions",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Forbidden"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Validation rule not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Validation rule not found"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unknown API Error"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "securitySchemes": {
+      "EpilotAuth": {
+        "type": "http",
+        "scheme": "bearer",
+        "description": "Authorization header with epilot OAuth2 bearer token",
+        "bearerFormat": "JWT"
+      },
+      "EpilotPublicAuth": {
+        "type": "http",
+        "scheme": "bearer",
+        "description": "Authorization header with epilot public access token",
+        "bearerFormat": "JWT"
+      }
+    },
+    "schemas": {
+      "GetValidationRulesResponse": {
+        "type": "object",
+        "description": "Response envelope for listing all validation rules within an organization.",
+        "properties": {
+          "results": {
+            "type": "array",
+            "description": "Flat list of all validation rules belonging to the authenticated organization.",
+            "items": {
+              "$ref": "#/components/schemas/ValidationRule"
+            }
+          }
+        }
+      },
+      "CreateValidationRuleRequest": {
+        "allOf": [
+          {
+            "$ref": "#/components/schemas/ValidationRuleBase"
+          },
+          {
+            "type": "object",
+            "required": [
+              "title",
+              "rule"
+            ]
+          }
+        ]
+      },
+      "UpdateValidationRuleRequest": {
+        "allOf": [
+          {
+            "$ref": "#/components/schemas/ValidationRuleBase"
+          }
+        ]
+      },
+      "ValidationRuleBase": {
+        "allOf": [
+          {
+            "type": "object",
+            "properties": {
+              "title": {
+                "type": "string",
+                "description": "Title of the validation rule."
+              },
+              "placeholder": {
+                "type": "string",
+                "description": "Placeholder for the validation rule."
+              },
+              "used_by": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/UsedBy"
+                },
+                "description": "Describes where and how a validation rule is applied."
+              },
+              "rule": {
+                "oneOf": [
+                  {
+                    "$ref": "#/components/schemas/RegexRuleType"
+                  },
+                  {
+                    "$ref": "#/components/schemas/PatternRuleType"
+                  },
+                  {
+                    "$ref": "#/components/schemas/NumericRuleType"
+                  },
+                  {
+                    "$ref": "#/components/schemas/ComparisonRuleType"
+                  }
+                ]
+              },
+              "contexts": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/ContextRequirement"
+                },
+                "description": "Declares the dynamic context a v2 rule needs at evaluation time.\n`context` condition values reference these sources by using the schema slug\nas the first segment of their `path`. Only applicable to v2 rules.\n"
+              }
+            }
+          }
+        ]
+      },
+      "ValidationRule": {
+        "allOf": [
+          {
+            "$ref": "#/components/schemas/ValidationRuleBase"
+          },
+          {
+            "type": "object",
+            "required": [
+              "_schema_version",
+              "_id",
+              "_organization_id",
+              "title",
+              "type",
+              "created_at",
+              "updated_at",
+              "created_by",
+              "updated_by"
+            ],
+            "properties": {
+              "_schema_version": {
+                "type": "string",
+                "description": "Schema version of the validation rule."
+              },
+              "_id": {
+                "type": "string",
+                "description": "Unique identifier for the validation rule."
+              },
+              "_organization_id": {
+                "type": "string",
+                "description": "Organization ID that owns this rule."
+              },
+              "created_at": {
+                "type": "string",
+                "description": "ISO timestamp when the rule was created."
+              },
+              "updated_at": {
+                "type": "string",
+                "description": "ISO timestamp when the rule was last updated."
+              },
+              "created_by": {
+                "type": "string",
+                "description": "User ID of the creator."
+              },
+              "updated_by": {
+                "type": "string",
+                "description": "User ID of the last updater."
+              }
+            }
+          }
+        ],
+        "description": "The Validation rule definition."
+      },
+      "UsedBy": {
+        "type": "object",
+        "description": "Describes where and how a validation rule is applied. Used to track associations between rules and the journeys or entity schemas that reference them.",
+        "required": [
+          "type"
+        ],
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "journey",
+              "entity"
+            ],
+            "description": "The context in which the rule is used - either a journey block or an entity schema attribute.",
+            "example": "journey"
+          },
+          "schema_slug": {
+            "type": "string",
+            "description": "Slug of the entity schema using this rule. Only applicable when `type` is `entity`.",
+            "example": "contact"
+          },
+          "source_id": {
+            "type": "string",
+            "description": "Unique identifier of the source (e.g. journey ID or entity attribute key) that references this rule.",
+            "example": "journey-xyz789"
+          }
+        },
+        "example": {
+          "type": "journey",
+          "source_id": "journey-xyz789"
+        }
+      },
+      "RegexRuleType": {
+        "description": "Validation rule that uses a regular expression to validate input.",
+        "type": "object",
+        "required": [
+          "type",
+          "conditions"
+        ],
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "regex"
+            ],
+            "description": "Indicates this is a regex-based validation rule."
+          },
+          "conditions": {
+            "$ref": "#/components/schemas/RegexCondition",
+            "description": "The conditions that must be met for the rule to trigger"
+          }
+        }
+      },
+      "PatternRuleType": {
+        "description": "Validation rule that uses a sequence of patterns to validate input.",
+        "type": "object",
+        "required": [
+          "type",
+          "conditions"
+        ],
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "pattern"
+            ],
+            "description": "Indicates this is a pattern-based validation rule."
+          },
+          "conditions": {
+            "$ref": "#/components/schemas/PatternCondition",
+            "description": "The conditions that must be met for the rule to trigger"
+          }
+        }
+      },
+      "NumericRuleType": {
+        "description": "Validation rule for numeric values, supporting range and digit count constraints.",
+        "type": "object",
+        "required": [
+          "type",
+          "conditions"
+        ],
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "numeric"
+            ],
+            "description": "Indicates this is a numeric-based validation rule."
+          },
+          "conditions": {
+            "$ref": "#/components/schemas/NumericCondition",
+            "description": "The conditions that must be met for the rule to trigger"
+          }
+        }
+      },
+      "RegexCondition": {
+        "description": "Condition definition for a regex-based validation rule (2 levels deep)",
+        "anyOf": [
+          {
+            "type": "object",
+            "description": "All conditions must be true (AND logic)",
+            "properties": {
+              "all": {
+                "type": "array",
+                "items": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/RegexFactCondition"
+                    },
+                    {
+                      "$ref": "#/components/schemas/RegexNestedCondition"
+                    }
+                  ]
+                }
+              }
+            },
+            "required": [
+              "all"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Any conditions must be true (OR logic)",
+            "properties": {
+              "any": {
+                "type": "array",
+                "items": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/RegexFactCondition"
+                    },
+                    {
+                      "$ref": "#/components/schemas/RegexNestedCondition"
+                    }
+                  ]
+                }
+              }
+            },
+            "required": [
+              "any"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "NOT condition (negation)",
+            "properties": {
+              "not": {
+                "anyOf": [
+                  {
+                    "$ref": "#/components/schemas/RegexFactCondition"
+                  },
+                  {
+                    "$ref": "#/components/schemas/RegexNestedCondition"
+                  }
+                ]
+              }
+            },
+            "required": [
+              "not"
+            ],
+            "additionalProperties": false
+          }
+        ]
+      },
+      "RegexNestedCondition": {
+        "description": "Nested condition with logical operators (level 2 only)",
+        "anyOf": [
+          {
+            "type": "object",
+            "properties": {
+              "all": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/RegexFactCondition"
+                }
+              }
+            },
+            "required": [
+              "all"
+            ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "any": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/RegexFactCondition"
+                }
+              }
+            },
+            "required": [
+              "any"
+            ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "not": {
+                "$ref": "#/components/schemas/RegexFactCondition"
+              }
+            },
+            "required": [
+              "not"
+            ]
+          }
+        ]
+      },
+      "RegexFactCondition": {
+        "description": "Fact-based condition for regex validation",
+        "type": "object",
+        "required": [
+          "fact",
+          "operator",
+          "value"
+        ],
+        "properties": {
+          "fact": {
+            "type": "string",
+            "enum": [
+              "inputValue"
+            ],
+            "description": "The name of the value to validate. Should always be 'inputValue' because this property name is passed to the engine"
+          },
+          "operator": {
+            "type": "string",
+            "enum": [
+              "regexMatch"
+            ],
+            "description": "The operator to use for comparison"
+          },
+          "value": {
+            "type": "string",
+            "description": "The actual regex"
+          },
+          "params": {
+            "description": "Additional parameters for the condition",
+            "type": "object",
+            "properties": {
+              "errorMessage": {
+                "type": "string",
+                "description": "Custom error message"
+              }
+            }
+          }
+        }
+      },
+      "PatternCondition": {
+        "description": "Condition definition for a pattern-based validation rule (2 levels deep)",
+        "anyOf": [
+          {
+            "type": "object",
+            "description": "All conditions must be true (AND logic)",
+            "properties": {
+              "all": {
+                "type": "array",
+                "items": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/PatternFactCondition"
+                    },
+                    {
+                      "$ref": "#/components/schemas/PatternNestedCondition"
+                    }
+                  ]
+                }
+              }
+            },
+            "required": [
+              "all"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Any conditions must be true (OR logic)",
+            "properties": {
+              "any": {
+                "type": "array",
+                "items": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/PatternFactCondition"
+                    },
+                    {
+                      "$ref": "#/components/schemas/PatternNestedCondition"
+                    }
+                  ]
+                }
+              }
+            },
+            "required": [
+              "any"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "NOT condition (negation)",
+            "properties": {
+              "not": {
+                "anyOf": [
+                  {
+                    "$ref": "#/components/schemas/PatternFactCondition"
+                  },
+                  {
+                    "$ref": "#/components/schemas/PatternNestedCondition"
+                  }
+                ]
+              }
+            },
+            "required": [
+              "not"
+            ],
+            "additionalProperties": false
+          }
+        ]
+      },
+      "PatternNestedCondition": {
+        "description": "Nested condition with logical operators (level 2 only)",
+        "anyOf": [
+          {
+            "type": "object",
+            "properties": {
+              "all": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/PatternFactCondition"
+                }
+              }
+            },
+            "required": [
+              "all"
+            ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "any": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/PatternFactCondition"
+                }
+              }
+            },
+            "required": [
+              "any"
+            ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "not": {
+                "$ref": "#/components/schemas/PatternFactCondition"
+              }
+            },
+            "required": [
+              "not"
+            ]
+          }
+        ]
+      },
+      "PatternFactCondition": {
+        "description": "Fact-based condition for pattern validation",
+        "type": "object",
+        "oneOf": [
+          {
+            "description": "Numeric condition (total-length fact)",
+            "required": [
+              "fact",
+              "operator",
+              "value"
+            ],
+            "properties": {
+              "fact": {
+                "type": "string",
+                "enum": [
+                  "total-length"
+                ],
+                "description": "The name of the value to validate."
+              },
+              "operator": {
+                "type": "string",
+                "enum": [
+                  "equal",
+                  "notEqual",
+                  "lessThan",
+                  "lessThanInclusive",
+                  "greaterThan",
+                  "greaterThanInclusive"
+                ],
+                "description": "Numeric comparison operator"
+              },
+              "value": {
+                "type": "number",
+                "description": "Numeric value to compare against"
+              },
+              "params": {
+                "description": "Additional parameters for the condition",
+                "type": "object",
+                "properties": {
+                  "errorMessage": {
+                    "type": "string",
+                    "description": "Custom error message"
+                  },
+                  "start": {
+                    "type": "number",
+                    "description": "From where to check"
+                  },
+                  "end": {
+                    "type": "number",
+                    "description": "To where to check"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "description": "Exact digits condition",
+            "required": [
+              "fact",
+              "operator",
+              "value"
+            ],
+            "properties": {
+              "fact": {
+                "type": "string",
+                "enum": [
+                  "static-check",
+                  "total-length"
+                ],
+                "description": "The name of the value to validate."
+              },
+              "operator": {
+                "type": "string",
+                "enum": [
+                  "exactlyNDigits"
+                ],
+                "description": "Exact digit count operator"
+              },
+              "value": {
+                "type": "number",
+                "description": "Number of digits required"
+              },
+              "params": {
+                "description": "Additional parameters for the condition",
+                "type": "object",
+                "properties": {
+                  "errorMessage": {
+                    "type": "string",
+                    "description": "Custom error message"
+                  },
+                  "start": {
+                    "type": "number",
+                    "description": "From where to check"
+                  },
+                  "end": {
+                    "type": "number",
+                    "description": "To where to check"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "description": "Array-based condition (in, notIn, contains, doesNotContain)",
+            "required": [
+              "fact",
+              "operator",
+              "value"
+            ],
+            "properties": {
+              "fact": {
+                "type": "string",
+                "enum": [
+                  "static-check"
+                ],
+                "description": "The name of the value to validate."
+              },
+              "operator": {
+                "type": "string",
+                "enum": [
+                  "in",
+                  "notIn",
+                  "contains",
+                  "doesNotContain"
+                ],
+                "description": "Array-based comparison operator"
+              },
+              "value": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                },
+                "description": "Array of string values for array-based operators"
+              },
+              "params": {
+                "description": "Additional parameters for the condition",
+                "type": "object",
+                "properties": {
+                  "errorMessage": {
+                    "type": "string",
+                    "description": "Custom error message"
+                  },
+                  "start": {
+                    "type": "number",
+                    "description": "From where to check"
+                  },
+                  "end": {
+                    "type": "number",
+                    "description": "To where to check"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "description": "String-based condition",
+            "required": [
+              "fact",
+              "operator",
+              "value"
+            ],
+            "properties": {
+              "fact": {
+                "type": "string",
+                "enum": [
+                  "static-check"
+                ],
+                "description": "The name of the value to validate."
+              },
+              "operator": {
+                "type": "string",
+                "enum": [
+                  "equal",
+                  "notEqual"
+                ],
+                "description": "String comparison operator"
+              },
+              "value": {
+                "type": "string",
+                "description": "String value to compare against"
+              },
+              "params": {
+                "description": "Additional parameters for the condition",
+                "type": "object",
+                "properties": {
+                  "errorMessage": {
+                    "type": "string",
+                    "description": "Custom error message"
+                  },
+                  "start": {
+                    "type": "number",
+                    "description": "From where to check"
+                  },
+                  "end": {
+                    "type": "number",
+                    "description": "To where to check"
+                  }
+                }
+              }
+            }
+          }
+        ]
+      },
+      "NumericCondition": {
+        "description": "Condition definition for a numeric-based validation rule (2 levels deep)",
+        "anyOf": [
+          {
+            "type": "object",
+            "description": "All conditions must be true (AND logic)",
+            "properties": {
+              "all": {
+                "type": "array",
+                "items": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/NumericFactCondition"
+                    },
+                    {
+                      "$ref": "#/components/schemas/NumericNestedCondition"
+                    }
+                  ]
+                }
+              }
+            },
+            "required": [
+              "all"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "Any conditions must be true (OR logic)",
+            "properties": {
+              "any": {
+                "type": "array",
+                "items": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/NumericFactCondition"
+                    },
+                    {
+                      "$ref": "#/components/schemas/NumericNestedCondition"
+                    }
+                  ]
+                }
+              }
+            },
+            "required": [
+              "any"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "description": "NOT condition (negation)",
+            "properties": {
+              "not": {
+                "anyOf": [
+                  {
+                    "$ref": "#/components/schemas/NumericFactCondition"
+                  },
+                  {
+                    "$ref": "#/components/schemas/NumericNestedCondition"
+                  }
+                ]
+              }
+            },
+            "required": [
+              "not"
+            ],
+            "additionalProperties": false
+          }
+        ]
+      },
+      "NumericNestedCondition": {
+        "description": "Nested condition with logical operators (level 2 only)",
+        "anyOf": [
+          {
+            "type": "object",
+            "properties": {
+              "all": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/NumericFactCondition"
+                }
+              }
+            },
+            "required": [
+              "all"
+            ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "any": {
+                "type": "array",
+                "items": {
+                  "$ref": "#/components/schemas/NumericFactCondition"
+                }
+              }
+            },
+            "required": [
+              "any"
+            ]
+          },
+          {
+            "type": "object",
+            "properties": {
+              "not": {
+                "$ref": "#/components/schemas/NumericFactCondition"
+              }
+            },
+            "required": [
+              "not"
+            ]
+          }
+        ]
+      },
+      "NumericFactCondition": {
+        "description": "Fact-based condition for numeric validation",
+        "type": "object",
+        "oneOf": [
+          {
+            "description": "Numeric value comparison",
+            "required": [
+              "fact",
+              "operator",
+              "value"
+            ],
+            "properties": {
+              "fact": {
+                "type": "string",
+                "enum": [
+                  "numeric-value",
+                  "total-length"
+                ],
+                "description": "The numeric value extracted from input; The amount of digits"
+              },
+              "operator": {
+                "type": "string",
+                "enum": [
+                  "equal",
+                  "notEqual",
+                  "lessThan",
+                  "lessThanInclusive",
+                  "greaterThan",
+                  "greaterThanInclusive"
+                ],
+                "description": "Numeric comparison operator"
+              },
+              "value": {
+                "type": "number",
+                "description": "Numeric value to compare against"
+              },
+              "params": {
+                "description": "Additional parameters for the condition",
+                "type": "object",
+                "properties": {
+                  "errorMessage": {
+                    "type": "string",
+                    "description": "Custom error message"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "description": "Integer digits count validation",
+            "required": [
+              "fact",
+              "operator",
+              "value"
+            ],
+            "properties": {
+              "fact": {
+                "type": "string",
+                "enum": [
+                  "integer-digits-count"
+                ],
+                "description": "Count of integer digits (excludes leading zeros unless allowed)"
+              },
+              "operator": {
+                "type": "string",
+                "enum": [
+                  "equal",
+                  "exactlyNDigits",
+                  "minIntegerDigits",
+                  "maxIntegerDigits"
+                ],
+                "description": "Digit count comparison operator"
+              },
+              "value": {
+                "type": "number",
+                "description": "Expected number of integer digits"
+              },
+              "params": {
+                "description": "Additional parameters for the condition",
+                "type": "object",
+                "properties": {
+                  "errorMessage": {
+                    "type": "string",
+                    "description": "Custom error message"
+                  },
+                  "allowLeadingZeroes": {
+                    "type": "boolean",
+                    "description": "Whether to count leading zeroes in digit count",
+                    "default": false
+                  }
+                }
+              }
+            }
+          },
+          {
+            "description": "Decimal digits count validation",
+            "required": [
+              "fact",
+              "operator",
+              "value"
+            ],
+            "properties": {
+              "fact": {
+                "type": "string",
+                "enum": [
+                  "decimal-digits-count"
+                ],
+                "description": "Count of decimal digits"
+              },
+              "operator": {
+                "type": "string",
+                "enum": [
+                  "equal",
+                  "minDecimalDigits",
+                  "maxDecimalDigits"
+                ],
+                "description": "Decimal digit count comparison operator"
+              },
+              "value": {
+                "type": "number",
+                "description": "Expected number of decimal digits"
+              },
+              "params": {
+                "description": "Additional parameters for the condition",
+                "type": "object",
+                "properties": {
+                  "errorMessage": {
+                    "type": "string",
+                    "description": "Custom error message"
+                  }
+                }
+              }
+            }
+          },
+          {
+            "description": "Leading zeros validation",
+            "required": [
+              "fact",
+              "operator",
+              "value"
+            ],
+            "properties": {
+              "fact": {
+                "type": "string",
+                "enum": [
+                  "has-leading-zeroes"
+                ],
+                "description": "Whether the input has leading zeros"
+              },
+              "operator": {
+                "type": "string",
+                "enum": [
+                  "equal",
+                  "notAllowed"
+                ],
+                "description": "Leading zeros check operator"
+              },
+              "value": {
+                "type": "boolean",
+                "description": "Whether leading zeros should be present or not"
+              },
+              "params": {
+                "description": "Additional parameters for the condition",
+                "type": "object",
+                "properties": {
+                  "errorMessage": {
+                    "type": "string",
+                    "description": "Custom error message"
+                  }
+                }
+              }
+            }
+          }
+        ]
+      },
+      "ComparisonRuleType": {
+        "type": "object",
+        "description": "Declarative validation rule (schema version v2). Supports predefined comparison operators\nover number, date and text inputs, with static, dynamic (context path) and relative-date\ncomparison values.\n",
+        "required": [
+          "input_type",
+          "conditions"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "input_type": {
+            "type": "string",
+            "enum": [
+              "number",
+              "date",
+              "text"
+            ],
+            "description": "The kind of input value the rule validates. Determines which operators are allowed."
+          },
+          "conditions": {
+            "type": "array",
+            "description": "The comparisons the input value must satisfy. All blocking conditions must pass\nfor the input to be valid; `allow_failure` conditions are advisory and excluded\nfrom the verdict. Must contain at least one condition (enforced at write time).\n",
+            "items": {
+              "$ref": "#/components/schemas/Condition"
+            }
+          }
+        }
+      },
+      "Condition": {
+        "type": "object",
+        "description": "A single comparison the input value must satisfy.",
+        "required": [
+          "id",
+          "operator",
+          "value",
+          "error_message"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "id": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 50,
+            "description": "Stable identifier of the condition within the rule, used for editing and error reporting."
+          },
+          "operator": {
+            "$ref": "#/components/schemas/Operator"
+          },
+          "value": {
+            "$ref": "#/components/schemas/ConditionValue"
+          },
+          "error_message": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 200,
+            "description": "Message shown to the end user when this condition fails."
+          },
+          "applies_when": {
+            "$ref": "#/components/schemas/AppliesWhen"
+          },
+          "allow_failure": {
+            "type": "boolean",
+            "default": false,
+            "description": "When true, the condition is advisory: it is always evaluated and reported\nwhen it fails, but it never takes part in the validity verdict.\nThe input is valid when every blocking (non-advisory) condition passes.\nA rule whose conditions are all advisory is always valid (warnings only).\n"
+          }
+        }
+      },
+      "Operator": {
+        "type": "string",
+        "description": "Predefined comparison operator. Compatibility (enforced at write time):\n- number: equal, notEqual, greaterThan, greaterThanInclusive, lessThan, lessThanInclusive, between, regexMatch,\n  maxDigits, maxDecimals\n- date: dateBefore, dateOnOrBefore, dateAfter, dateOnOrAfter, dateBetween, notInFuture, notInPast, regexMatch\n- text: equal, notEqual, contains, doesNotContain, startsWith, endsWith, regexMatch, lengthBetween,\n  greaterThan, greaterThanInclusive, lessThan, lessThanInclusive, between, maxDigits, maxDecimals\nRange operators (between, dateBetween, lengthBetween) require a `range` value;\nunary operators (notInFuture, notInPast) require a `none` value; all others require a scalar value.\nregexMatch validates the raw input string's format and always takes a static string pattern.\nNumeric comparison operators on text rules parse the input as a number at evaluation time\n(free-text fields often hold numbers); unparsable input fails the condition.\nmaxDigits limits how many digits the written input may contain in total (grouping\nseparators, sign and the decimal separator are not counted); maxDecimals limits how many\ndigits may follow the decimal separator. Both take a non-negative integer comparison value\nand, like the other numeric operators, are also allowed on text rules.\n",
+        "enum": [
+          "equal",
+          "notEqual",
+          "greaterThan",
+          "greaterThanInclusive",
+          "lessThan",
+          "lessThanInclusive",
+          "between",
+          "dateBefore",
+          "dateOnOrBefore",
+          "dateAfter",
+          "dateOnOrAfter",
+          "dateBetween",
+          "notInFuture",
+          "notInPast",
+          "contains",
+          "doesNotContain",
+          "startsWith",
+          "endsWith",
+          "regexMatch",
+          "lengthBetween",
+          "maxDigits",
+          "maxDecimals"
+        ]
+      },
+      "ConditionValue": {
+        "description": "The comparison value of a condition - a scalar, a range of scalars, or nothing (unary operators).",
+        "oneOf": [
+          {
+            "$ref": "#/components/schemas/StaticValue"
+          },
+          {
+            "$ref": "#/components/schemas/ContextValue"
+          },
+          {
+            "$ref": "#/components/schemas/RelativeDateValue"
+          },
+          {
+            "$ref": "#/components/schemas/RangeValue"
+          },
+          {
+            "$ref": "#/components/schemas/NoValue"
+          }
+        ]
+      },
+      "ScalarValue": {
+        "description": "A single comparison value - static, resolved from context, or a relative date.",
+        "oneOf": [
+          {
+            "$ref": "#/components/schemas/StaticValue"
+          },
+          {
+            "$ref": "#/components/schemas/ContextValue"
+          },
+          {
+            "$ref": "#/components/schemas/RelativeDateValue"
+          }
+        ]
+      },
+      "StaticValue": {
+        "type": "object",
+        "description": "A fixed comparison value.",
+        "required": [
+          "source",
+          "data"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "source": {
+            "type": "string",
+            "enum": [
+              "static"
+            ]
+          },
+          "data": {
+            "description": "The literal value. Numbers for numeric comparisons, ISO 8601 date strings for date comparisons, strings for text comparisons.",
+            "oneOf": [
+              {
+                "type": "number"
+              },
+              {
+                "type": "string"
+              },
+              {
+                "type": "boolean"
+              }
+            ]
+          }
+        }
+      },
+      "ContextValue": {
+        "type": "object",
+        "description": "A dynamic comparison value resolved from runtime context, e.g. `contract.installment_amount`\nor `previous_reading.value`. The first path segment must match the `name` of a declared\ncontext requirement.\n",
+        "required": [
+          "source",
+          "path"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "source": {
+            "type": "string",
+            "enum": [
+              "context"
+            ]
+          },
+          "path": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 200,
+            "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*(\\.[a-zA-Z0-9_]+)*$",
+            "description": "Dot-separated path into the resolved context."
+          },
+          "adjust": {
+            "$ref": "#/components/schemas/ValueAdjustment"
+          }
+        }
+      },
+      "ValueAdjustment": {
+        "type": "object",
+        "description": "Adjusts a context-resolved numeric value before comparison, e.g. \"context value plus 10 percent\".\nUsed to express tolerance bands such as \"at most 10% above the current instalment amount\".\n",
+        "required": [
+          "type",
+          "value",
+          "direction"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "percent",
+              "absolute"
+            ]
+          },
+          "value": {
+            "description": "The adjustment amount - a fixed number, or a context path resolving to a number\n(e.g. a per-contract percentage limit). Contextual adjustment values must not\ncarry a nested adjustment.\n",
+            "oneOf": [
+              {
+                "type": "number",
+                "minimum": 0
+              },
+              {
+                "$ref": "#/components/schemas/ContextValue"
+              }
+            ]
+          },
+          "direction": {
+            "type": "string",
+            "enum": [
+              "increase",
+              "decrease"
+            ]
+          },
+          "rounding": {
+            "type": "string",
+            "enum": [
+              "up",
+              "down"
+            ],
+            "description": "Rounds the adjusted result to a whole number - `up` (ceiling) or `down` (floor).\nOmitted means no rounding. Used for bounds like \"round up(current × 0.9) to whole euros\".\n"
+          }
+        }
+      },
+      "RelativeDateValue": {
+        "type": "object",
+        "description": "A date relative to the evaluation moment, e.g. \"today minus 30 days\". Only valid for date rules.",
+        "required": [
+          "source",
+          "offset",
+          "unit"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "source": {
+            "type": "string",
+            "enum": [
+              "relative_date"
+            ]
+          },
+          "offset": {
+            "type": "integer",
+            "minimum": -36500,
+            "maximum": 36500,
+            "description": "Offset from the anchor. Negative values are in the past, positive in the future, 0 is the anchor itself."
+          },
+          "unit": {
+            "type": "string",
+            "enum": [
+              "days",
+              "months",
+              "years"
+            ]
+          },
+          "anchor": {
+            "type": "string",
+            "enum": [
+              "today"
+            ],
+            "default": "today"
+          }
+        }
+      },
+      "RangeValue": {
+        "type": "object",
+        "description": "A lower and upper bound for range operators (between, dateBetween, lengthBetween). Bounds are inclusive.",
+        "required": [
+          "source",
+          "min",
+          "max"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "source": {
+            "type": "string",
+            "enum": [
+              "range"
+            ]
+          },
+          "min": {
+            "$ref": "#/components/schemas/ScalarValue"
+          },
+          "max": {
+            "$ref": "#/components/schemas/ScalarValue"
+          }
+        }
+      },
+      "NoValue": {
+        "type": "object",
+        "description": "No comparison value - used by unary operators such as notInFuture / notInPast.",
+        "required": [
+          "source"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "source": {
+            "type": "string",
+            "enum": [
+              "none"
+            ]
+          }
+        }
+      },
+      "AppliesWhen": {
+        "type": "object",
+        "description": "Optional precondition on a condition: the condition only takes part in the\nvalidation when this comparison over context holds. Examples: apply the\ndual-tariff reference only when `contract.htnt` is not empty, or run a\nplausibility check only when a context value reaches a threshold.\n",
+        "required": [
+          "path",
+          "operator"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "path": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 200,
+            "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*(\\.[a-zA-Z0-9_]+)*$",
+            "description": "Dot-separated context path whose first segment must match a declared context schema."
+          },
+          "operator": {
+            "type": "string",
+            "enum": [
+              "equal",
+              "notEqual",
+              "greaterThan",
+              "greaterThanInclusive",
+              "lessThan",
+              "lessThanInclusive",
+              "isEmpty",
+              "isNotEmpty"
+            ],
+            "description": "Comparison applied to the resolved context value. `isEmpty` / `isNotEmpty`\ntake no `value`; all other operators require one.\n"
+          },
+          "value": {
+            "description": "Static comparison value for binary operators.",
+            "oneOf": [
+              {
+                "type": "number"
+              },
+              {
+                "type": "string"
+              },
+              {
+                "type": "boolean"
+              }
+            ]
+          }
+        }
+      },
+      "ContextRequirement": {
+        "type": "object",
+        "description": "An entity context source the rule needs at evaluation time, referenced by `context`\nvalue paths via the schema slug as their first segment (e.g. `contract.installment_amount`).\nHow the source is resolved (which entity instance) is decided by the consuming surface,\nnot by the rule. Meter reading comparisons use the meter/meter_counter entity schemas\n(e.g. `meter_counter.current_consumption` for the previous reading value).\n",
+        "required": [
+          "schema"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "schema": {
+            "type": "string",
+            "minLength": 1,
+            "description": "Entity schema slug.",
+            "example": "contract"
+          }
+        }
+      }
+    }
+  },
+  "servers": [
+    {
+      "url": "https://validation-rules.sls.epilot.io"
+    }
+  ]
+}