Enum ValidationRule 

pub enum ValidationRule {
    Required,
    Pattern {
        pattern: String,
        message: Option<String>,
    },
    Length {
        min: Option<usize>,
        max: Option<usize>,
    },
    Range {
        min: Option<i64>,
        max: Option<i64>,
    },
    Enum {
        values: Vec<String>,
    },
    Checksum {
        algorithm: String,
    },
    CrossField {
        field: String,
        operator: String,
    },
    Conditional {
        condition: String,
        then_rules: Vec<Box<ValidationRule>>,
    },
    All(Vec<ValidationRule>),
    Any(Vec<ValidationRule>),
    OneOf {
        fields: Vec<String>,
    },
    AnyOf {
        fields: Vec<String>,
    },
    ConditionalRequired {
        if_field_present: String,
        then_required: Vec<String>,
    },
    RequiredIfAbsent {
        absent_field: String,
        then_required: Vec<String>,
    },
}

A validation rule that can be applied to a field.

Rules define constraints on field values and are evaluated during input validation. Multiple rules can be combined on a single field.

Variants

Required

Field is required (non-null) and must have a value.

Pattern

Field value must match a regular expression pattern.

Fields

pattern: String

The regex pattern to match.

message: Option<String>

Optional error message for when pattern doesn’t match.

Length

String field length constraints.

Fields

min: Option<usize>

Minimum length (inclusive).

max: Option<usize>

Maximum length (inclusive).

Range

Numeric field range constraints.

Fields

min: Option<i64>

Minimum value (inclusive).

max: Option<i64>

Maximum value (inclusive).

Enum

Field value must be one of allowed enum values.

Fields

values: Vec<String>

List of allowed values.

Checksum

Checksum validation for structured data.

Fields

algorithm: String

Algorithm to use (e.g., “luhn”, “mod97”).

CrossField

Cross-field validation rule.

Fields

field: String

Reference to another field to compare against.

operator: String

Comparison operator (“lt”, “lte”, “eq”, “gte”, “gt”).

Conditional

Conditional validation - only validate if condition is met.

Fields

condition: String

The condition expression.

then_rules: Vec<Box<ValidationRule>>

Rules to apply if condition is true.

All(Vec<ValidationRule>)

Composite rule - all rules must pass.

Any(Vec<ValidationRule>)

Composite rule - at least one rule must pass.

OneOf

Exactly one field from the set must be provided (mutually exclusive).

Useful for “create or reference” patterns where you must provide EITHER an ID to reference an existing entity OR the fields to create a new one, but not both.

Example

// Either provide entityId OR (name + description), but not both
OneOf { fields: vec!["name".to_string(), "description".to_string()] }

Fields

fields: Vec<String>

List of field names - exactly one must be provided

AnyOf

At least one field from the set must be provided.

Useful for optional but not-all-empty patterns.

Example

// Provide at least one of: email, phone, address
AnyOf { fields: vec!["email".to_string(), "phone".to_string(), "address".to_string()] }

Fields

fields: Vec<String>

List of field names - at least one must be provided

ConditionalRequired

If a field is present, then other fields are required.

Used for conditional requirements based on presence of another field.

Example

// If entityId is provided, then createdAt is required
ConditionalRequired {
    if_field_present: "entityId".to_string(),
    then_required: vec!["createdAt".to_string()]
}

Fields

if_field_present: String

If this field is present (not null/missing)

then_required: Vec<String>

Then these fields are required

RequiredIfAbsent

If a field is absent/null, then other fields are required.

Used for “provide this OR that” patterns at the object level.

Example

// If addressId is missing, then street+city+zip are required
RequiredIfAbsent {
    absent_field: "addressId".to_string(),
    then_required: vec!["street".to_string(), "city".to_string(), "zip".to_string()]
}

Fields

absent_field: String

If this field is absent/null

then_required: Vec<String>

Then these fields are required

Implementations

impl ValidationRule

pub const fn is_required(&self) -> bool

Check if this is a required field validation.

pub fn description(&self) -> String

Get a human-readable description of this rule.

Trait Implementations

impl Clone for ValidationRule

fn clone(&self) -> ValidationRule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ValidationRule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ValidationRule

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ValidationRule

fn eq(&self, other: &ValidationRule) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ValidationRule

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ValidationRule