@epilot/sdk 2.0.0-beta.2 → 2.0.0-beta.4

package/definitions/validation-rules.json

@@ -0,0 +1,1491 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "title": "Validation Rules API",
+    "version": "1.0.0"
+  },
+  "tags": [
+    {
+      "name": "Validation Rules",
+      "description": "Endpoints for managing validation rules"
+    }
+  ],
+  "security": [
+    {
+      "EpilotAuth": []
+    }
+  ],
+  "paths": {
+    "/v1/validation-rules": {
+      "get": {
+        "operationId": "getValidationRules",
+        "summary": "Get all validation rules by organization Id",
+        "description": "Gets all validation rules by organization Id",
+        "tags": [
+          "Validation Rules"
+        ],
+        "security": [
+          {
+            "EpilotAuth": []
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/GetValidationRulesResponse"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request - Invalid request body",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request body"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unknown API Error"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "operationId": "createValidationRule",
+        "summary": "Create Validation Rule",
+        "description": "Creates a new validation rule",
+        "tags": [
+          "Validation Rules"
+        ],
+        "security": [
+          {
+            "EpilotAuth": []
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateValidationRuleRequest"
+              }
+            }
+          },
+          "description": "Payload"
+        },
+        "responses": {
+          "201": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/v1/validation-rules/{ruleId}": {
+      "get": {
+        "operationId": "getValidationRuleById",
+        "summary": "Get validation rule by ID",
+        "description": "Retrieves a specific validation rule by its 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."
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                }
+              }
+            }
+          },
+          "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": "Update Validation Rule (partial update)",
+        "description": "Updates an existing validation rule partially by 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 update."
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateValidationRuleRequest"
+              }
+            }
+          },
+          "description": "Fields to update in the validation rule"
+        },
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request - Invalid request body",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request body"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal Server Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Unknown API Error"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "operationId": "deleteValidationRule",
+        "summary": "Delete Validation Rule",
+        "description": "Deletes a validation rule by 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 delete."
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "Validation rule deleted successfully"
+          },
+          "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": "Add a reference to the usedBy array",
+        "description": "Adds a single reference to the usedBy array of a validation rule",
+        "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."
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UsedBy"
+              }
+            }
+          },
+          "description": "The usedBy reference to add"
+        },
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request - Invalid request body",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request body"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "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": "Remove a reference from the usedBy array",
+        "description": "Removes a specific reference from the usedBy array of a validation rule",
+        "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."
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UsedBy"
+              }
+            }
+          },
+          "description": "The usedBy reference to remove"
+        },
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ValidationRule"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request - Invalid request body",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "message": {
+                      "type": "string",
+                      "example": "Invalid request body"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "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",
+        "properties": {
+          "results": {
+            "type": "array",
+            "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"
+                  }
+                ]
+              }
+            }
+          }
+        ]
+      },
+      "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",
+        "required": [
+          "type"
+        ],
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "journey",
+              "entity"
+            ],
+            "description": "The context in which the rule is used (e.g., journey or entity)."
+          },
+          "schema_slug": {
+            "type": "string",
+            "description": "Slug of the schema using this rule for entities."
+          },
+          "source_id": {
+            "type": "string",
+            "description": "Source identifier for the usage context."
+          }
+        },
+        "description": "Describes where and how a validation rule is applied."
+      },
+      "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"
+                  }
+                }
+              }
+            }
+          }
+        ]
+      }
+    }
+  },
+  "servers": [
+    {
+      "url": "https://validation-rules.sls.epilot.io"
+    }
+  ]
+}