Enum ValidationType 

pub enum ValidationType {
    Email,
    Url,
    Uuid,
    Cuid,
    Cuid2,
    NanoId,
    Ulid,
    Regex(String),
    MinLength(usize),
    MaxLength(usize),
    Length {
        min: usize,
        max: usize,
    },
    StartsWith(String),
    EndsWith(String),
    Contains(String),
    Alpha,
    Alphanumeric,
    Lowercase,
    Uppercase,
    Trim,
    NoWhitespace,
    Ip,
    Ipv4,
    Ipv6,
    CreditCard,
    Phone,
    Slug,
    Hex,
    Base64,
    Json,
    Min(f64),
    Max(f64),
    Range {
        min: f64,
        max: f64,
    },
    Positive,
    Negative,
    NonNegative,
    NonPositive,
    Integer,
    MultipleOf(f64),
    Finite,
    MinItems(usize),
    MaxItems(usize),
    Items {
        min: usize,
        max: usize,
    },
    Unique,
    NonEmpty,
    Past,
    Future,
    PastOrPresent,
    FutureOrPresent,
    After(String),
    Before(String),
    Required,
    NotEmpty,
    OneOf(Vec<ValidationValue>),
    Custom(String),
}

Types of validation rules.

Variants

Email

Valid email format.

Url

Valid URL format.

Uuid

Valid UUID format (v1-v5).

Cuid

Valid CUID format.

Cuid2

Valid CUID2 format.

NanoId

Valid NanoId format.

Ulid

Valid ULID format.

Regex(String)

Matches regex pattern.

MinLength(usize)

Minimum string length.

MaxLength(usize)

Maximum string length.

Length

String length range.

Fields

min: usize

max: usize

StartsWith(String)

String starts with prefix.

EndsWith(String)

String ends with suffix.

Contains(String)

String contains substring.

Alpha

Only alphabetic characters.

Alphanumeric

Only alphanumeric characters.

Lowercase

Only lowercase characters.

Uppercase

Only uppercase characters.

Trim

Trimmed (no leading/trailing whitespace).

NoWhitespace

No whitespace characters.

Ip

Valid IP address (v4 or v6).

Ipv4

Valid IPv4 address.

Ipv6

Valid IPv6 address.

CreditCard

Valid credit card number.

Phone

Valid phone number format.

Slug

URL-safe slug format.

Hex

Valid hexadecimal string.

Base64

Valid base64 string.

Json

Valid JSON string.

Min(f64)

Minimum value.

Max(f64)

Maximum value.

Range

Value within range (inclusive).

Fields

min: f64

max: f64

Positive

Value > 0.

Negative

Value < 0.

NonNegative

Value >= 0.

NonPositive

Value <= 0.

Integer

Must be integer (no decimal).

MultipleOf(f64)

Value is multiple of n.

Finite

Must be finite (not Infinity/NaN).

MinItems(usize)

Minimum array length.

MaxItems(usize)

Maximum array length.

Items

Array length range.

Fields

min: usize

max: usize

Unique

All items must be unique.

NonEmpty

Array must have at least one item.

Past

Date must be in the past.

Future

Date must be in the future.

PastOrPresent

Date must be past or present.

FutureOrPresent

Date must be future or present.

After(String)

Date must be after specified date.

Before(String)

Date must be before specified date.

Required

Field must not be null (for optional fields).

NotEmpty

Field must not be empty.

OneOf(Vec<ValidationValue>)

Value must be one of the specified values.

Custom(String)

Use a custom validator function.

Implementations

impl ValidationType

pub fn default_message(&self, field_name: &str) -> String

Get the default error message for this validation type.

pub fn is_string_rule(&self) -> bool

Check if this rule applies to strings.

pub fn is_id_format_rule(&self) -> bool

Check if this rule validates an identifier format (UUID, CUID, etc.).

pub fn is_numeric_rule(&self) -> bool

Check if this rule applies to numbers.

pub fn is_array_rule(&self) -> bool

Check if this rule applies to arrays.

pub fn is_date_rule(&self) -> bool

Check if this rule applies to dates.

pub fn validator_name(&self) -> &'static str

Get the validator name (for code generation).

Trait Implementations

impl Clone for ValidationType

fn clone(&self) -> ValidationType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValidationType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ValidationType

fn deserialize<__D>( __deserializer: __D, ) -> Result<ValidationType, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ValidationType

fn eq(&self, other: &ValidationType) -> 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 ValidationType

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ValidationType