@vinejs/vine - v4.2.0
    Preparing search index...

    Class VineNativeEnum<Values>

    VineNativeEnum represents an enum data type that performs validation against a pre-defined choices list.

    The choices list is derived from TypeScript enum data type or an object with string or number values. This allows you to validate against native TypeScript enums.

    enum Status {
      Active = 'active',
      Inactive = 'inactive'
    }

    const schema = vine.nativeEnum(Status)

    const Colors = {
      RED: 'red',
      BLUE: 'blue',
      GREEN: 'green'
    } as const

    const schema = vine.nativeEnum(Colors)

    Type Parameters

    • Values extends EnumLike

      The enum-like type containing allowed values

    Hierarchy (View Summary)

    Index

    Constructors

    constructor

    Properties

    [ITYPE] [OTYPE] [COTYPE] dataTypeValidator? options rules [SUBTYPE]

    Methods

    toJSONSchema parse use bail optional nullable meta transform [PARSE] clone

    Constructors

    Properties

    "[ITYPE]": Values[keyof Values]

    Define the input type of the schema for TypeScript inference

    "[OTYPE]": Values[keyof Values]

    The output value type of the field after validation. The property points to a type only and not the real value.

    "[COTYPE]": Values[keyof Values]

    Type marker for camelCase output type inference

    dataTypeValidator?: Validation<any>

    The validation to use for validating the schema data type. Using a data type validator guards custom rules to only run when the data type validation passes.

    class StringSchema extends BaseLiteralType {
      dataTypeValidator = stringDataTypeRule
    }
    options: FieldOptions

    Configuration options for this field including bail mode, nullability, and parsing

    rules: {
        enum: (
            ...options: [
                options: {
                    choices: readonly any[]
                    | ((field: FieldContext) => readonly any[]);
                },
            ],
        ) => Validation<
            { choices: readonly any[]
            | ((field: FieldContext) => readonly any[]) },
        >;
    } = ...

    Static collection of all available validation rules for native enums

    "[SUBTYPE]": string = 'enum'

    The subtype identifier for the literal schema field

    Methods

    • Define a method to parse the input value. The method is invoked before any validation and hence you must perform type-checking to know the value you are working it.

      Parameters

      • callback: ParseFn

      Returns this

    • Adds a validation rule to the schema's validation chain. Rules are executed in the order they are added.

      Parameters

      Returns this

      This schema instance for method chaining

      vine.string().use(minLength({ length: 3 }))
      vine.number().use(customRule({ strict: true }))

    • Enable/disable bail mode for this field. In bail mode, field validations stop after the first error.

      Parameters

      • state: boolean

        Whether to enable bail mode

      Returns VineNativeEnum<Values>

      This schema instance for method chaining

      vine.string().bail(false) // Continue validation after first error
      vine.number().bail(true)  // Stop after first error (default)

    • Compiles the literal schema type into a compiler node. This method transforms the schema definition into a format that the validation compiler can process.

      Parameters

      • propertyName: string

        Name of the property being compiled

      • refs: RefsStore

        Reference store for the compiler

      • options: ParserOptions

        Parser options including camelCase conversion

      Returns FieldNode & {} & { subtype: string }

      Compiled literal node with subtype information

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods