@epilot/sdk 2.1.9 → 2.2.0

package/definitions/validation-rules.json

@@ -1,1491 +0,0 @@
-{
-  "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"
-    }
-  ]
-}