Enum IssueCode 

#[non_exhaustive]
pub enum IssueCode {
    InvalidType {
        expected: String,
        received: String,
    },
    TooSmall {
        origin: SizeOrigin,
        minimum: Value,
        inclusive: bool,
    },
    TooBig {
        origin: SizeOrigin,
        maximum: Value,
        inclusive: bool,
    },
    InvalidLength {
        origin: SizeOrigin,
        expected: usize,
    },
    InvalidString {
        validation: StringValidation,
    },
    InvalidFormat {
        format: FormatKind,
    },
    InvalidDate {
        kind: DateKind,
    },
    InvalidTimezoneOffset {
        expected: String,
    },
    NotInPast {
        kind: DateKind,
    },
    NotInFuture {
        kind: DateKind,
    },
    NotInt,
    NotFinite,
    NotMultipleOf {
        divisor: Value,
    },
    NotSafeInteger,
    InvalidLiteral {
        expected: Value,
    },
    InvalidEnumValue {
        options: Vec<String>,
    },
    InvalidUnion,
    InvalidDiscriminator {
        options: Vec<Value>,
    },
    NotUnique,
    MissingContains,
    DuplicateKey,
    InvalidMapEntry,
    MissingField,
    UnrecognizedField,
    PathOutsideBase {
        base: String,
    },
    PathNotAbsolute,
    PathNotRelative,
    PathNotFound,
    PathNotFile,
    PathNotDir,
    JsonTooDeep {
        max_depth: usize,
    },
    FileTypeNotAllowed {
        kind: FileTypeKind,
        actual: String,
        allowed: Vec<String>,
    },
    FileTypeDenied {
        kind: FileTypeKind,
        actual: String,
    },
    FileTypeUnknown {
        kind: FileTypeKind,
    },
    ChecksumMismatch {
        algorithm: String,
    },
    MissingExif,
    SerializeError {
        detail: String,
    },
    IoError,
    ParseError,
    Custom {
        code: String,
    },
}

Validation issue code — describes what went wrong.

Every variant except Custom is produced by vld itself; Custom is reserved for user-defined codes (refine, custom, super_refine, IssueBuilder). See the module docs for the key of every variant.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

InvalidType

Wrong JSON type.

Fields

expected: String

received: String

TooSmall

Below a lower bound. minimum is a JSON number, or a string for Decimal / Date / DateTime origins.

Fields

origin: SizeOrigin

minimum: Value

inclusive: bool

TooBig

Above an upper bound (see TooSmall).

Fields

origin: SizeOrigin

maximum: Value

inclusive: bool

InvalidLength

Exact length mismatch.

Fields

origin: SizeOrigin

expected: usize

InvalidString

String format / content check failed.

Fields

validation: StringValidation

InvalidFormat

A non-string schema could not parse its textual format.

Fields

format: FormatKind

InvalidDate

Not a valid date / datetime.

Fields

kind: DateKind

InvalidTimezoneOffset

Datetime offset differs from the required one (±HH:MM).

Fields

expected: String

NotInPast

Date / datetime is not in the past.

Fields

kind: DateKind

NotInFuture

Date / datetime is not in the future.

Fields

kind: DateKind

NotInt

Number is not an integer.

NotFinite

Number is NaN or infinite.

NotMultipleOf

Number is not a multiple of divisor.

Fields

divisor: Value

NotSafeInteger

Number is outside -(2^53-1)..=2^53-1.

InvalidLiteral

Value differs from the literal.

Fields

expected: Value

InvalidEnumValue

String is not one of the enum options.

Fields

options: Vec<String>

InvalidUnion

No union variant matched (followed by every variant’s issues).

InvalidDiscriminator

Discriminator value matches no variant.

Fields

options: Vec<Value>

NotUnique

Array item repeats an earlier one (unique()).

MissingContains

Array lacks the contains(...) value.

DuplicateKey

Map key repeats an earlier one.

InvalidMapEntry

Map entry is not a [key, value] pair.

MissingField

Required field is missing or null.

UnrecognizedField

Field not declared by a strict object.

PathOutsideBase

Path escapes the within(base) directory.

Fields

base: String

PathNotAbsolute

Path must be absolute.

PathNotRelative

Path must be relative.

PathNotFound

Path does not exist (exists(), file(), dir(), vld::file()).

PathNotFile

Path exists but is not a regular file.

PathNotDir

Path exists but is not a directory.

JsonTooDeep

JSON nesting is deeper than max_depth.

Fields

max_depth: usize

FileTypeNotAllowed

File extension / media type / magic type is not in the allow list.

Fields

kind: FileTypeKind

actual: String

allowed: Vec<String>

FileTypeDenied

File extension / media type / magic type is on the deny list.

Fields

kind: FileTypeKind

actual: String

FileTypeUnknown

File media / magic type could not be detected.

Fields

kind: FileTypeKind

ChecksumMismatch

File hash differs (algorithm is "SHA-256" or "MD5").

Fields

algorithm: String

MissingExif

Image has no EXIF metadata.

SerializeError

A validated value could not be serialized to JSON.

Fields

detail: String

IoError

Filesystem error.

ParseError

Input is not valid JSON.

Custom

User-defined code.

Fields

code: String

Implementations

impl IssueCode

pub fn key(&self) -> &str

Stable snake_case key for this code (the user code for Custom).

pub fn message_keys(&self) -> Vec<String>

Message-template keys, most specific first.

E.g. ["too_small.string", "too_small"]; exclusive bounds use too_small_exclusive / too_big_exclusive; Custom codes fall back to "custom". Resolvers (MessageResolver) are asked in this order.

pub fn plural_count(&self) -> Option<u64>

Count selecting a plural template variant: the minimum / maximum of too_small / too_big or the expected of invalid_length, when it is a non-negative integer.

pub fn params(&self) -> Vec<(&'static str, String)>

Key-value parameters for message templates ({minimum}, {expected}, …).

pub fn default_message(&self) -> String

Default English message, rendered from the english() template table and params().

Size checks with a count of 1 use the _one variant ("String must be exactly 1 character"); invalid_type type keys render through their type.<key> label when one exists.

Trait Implementations

impl Clone for IssueCode

fn clone(&self) -> IssueCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IssueCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IssueCode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IssueCode

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for IssueCode

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 IssueCode