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

Expected type name ("string", "object", …).

received: String

Received JSON type name.

TooSmall

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

Fields

origin: SizeOrigin

What the bound was measured on.

minimum: Value

The lower bound.

inclusive: bool

true for >=, false for >.

TooBig

Above an upper bound (see TooSmall).

Fields

origin: SizeOrigin

What the bound was measured on.

maximum: Value

The upper bound.

inclusive: bool

true for <=, false for <.

InvalidLength

Exact length mismatch.

Fields

origin: SizeOrigin

What the length was measured on.

expected: usize

Required exact length.

InvalidString

String format / content check failed.

Fields

validation: StringValidation

The check that failed.

InvalidFormat

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

Fields

format: FormatKind

The format that could not be parsed.

InvalidDate

Not a valid date / datetime.

Fields

kind: DateKind

Date, datetime or time.

InvalidTimezoneOffset

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

Fields

expected: String

Required offset (±HH:MM).

NotInPast

Date / datetime is not in the past.

Fields

kind: DateKind

Date or datetime.

NotInFuture

Date / datetime is not in the future.

Fields

kind: DateKind

Date or datetime.

NotInt

Number is not an integer.

NotFinite

Number is NaN or infinite.

NotMultipleOf

Number is not a multiple of divisor.

Fields

divisor: Value

The required divisor.

NotSafeInteger

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

InvalidLiteral

Value differs from the literal.

Fields

expected: Value

The literal value.

InvalidEnumValue

String is not one of the enum options.

Fields

options: Vec<String>

Allowed values.

InvalidUnion

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

InvalidDiscriminator

Discriminator value matches no variant.

Fields

options: Vec<Value>

Discriminator values of the variants.

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

The base directory.

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

Allowed nesting depth.

FileTypeNotAllowed

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

Fields

kind: FileTypeKind

Which property was checked.

actual: String

The file’s value.

allowed: Vec<String>

Allowed values.

FileTypeDenied

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

Fields

kind: FileTypeKind

Which property was checked.

actual: String

The file’s value.

FileTypeUnknown

File media / magic type could not be detected.

Fields

kind: FileTypeKind

Which property could not be detected.

ChecksumMismatch

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

Fields

algorithm: String

"SHA-256" or "MD5".

MissingExif

Image has no EXIF metadata.

SerializeError

A validated value could not be serialized to JSON.

Fields

detail: String

The serializer’s message.

IoError

Filesystem error.

ParseError

Input is not valid JSON.

Custom

User-defined code.

Fields

code: String

The user-defined code.

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