Class VineObject<Properties, Input, Output, CamelCaseOutput>

VineObject represents an object value in the validation schema. It validates objects with predefined properties, supports conditional groups, and provides control over unknown properties.

Example

const schema = vine.object({
  name: vine.string(),
  email: vine.string().email(),
  age: vine.number().min(0)
})

const result = await vine.validate({
  schema,
  data: { name: 'John', email: 'john@example.com', age: 30 }
})

Type Parameters

Properties extends Record<string, SchemaTypes>
Record of property names to their schema types
Input
The expected input type for this object
Output
The output type after validation and transformation
CamelCaseOutput
The output type with camelCase property names

Hierarchy (View Summary)

BaseType<Input, Output, CamelCaseOutput>
- VineObject

Implements

WithJSONSchema

Index

Constructors

constructor

new VineObject<
    Properties extends Record<string, SchemaTypes>,
    Input,
    Output,
    CamelCaseOutput,
>(
    properties: Properties,
    options?: FieldOptions,
    validations?: Validation<any>[],
): VineObject<Properties, Input, Output, CamelCaseOutput>
Creates a new VineObject instance with property schemas and optional configuration.
Type Parameters
- Properties extends Record<string, SchemaTypes>
  Record of property names to their schema types
- Input
  The expected input type for this object
- Output
  The output type after validation and transformation
- CamelCaseOutput
  The output type with camelCase property names
Parameters
- properties: Properties
  Record of property names to their validation schemas
- Optionaloptions: FieldOptions
  Field options like bail mode and nullability
- Optionalvalidations: Validation<any>[]
  Initial set of validations to apply
Returns VineObject<Properties, Input, Output, CamelCaseOutput>
Throws
Error if properties is not provided
Overrides BaseType.constructor
- Defined in src/schema/object/main.ts:192

Properties

[ITYPE]

"[ITYPE]": Input

Define the input type of the schema for TypeScript inference

[OTYPE]

"[OTYPE]": Output

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

[COTYPE]

"[COTYPE]": CamelCaseOutput

Type marker for camelCase output type inference

[UNIQUE_NAME]

"[UNIQUE_NAME]": string = 'vine.object'

Unique name identifier for union type resolution

Methods

parse

parse(callback: ParseFn): this
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 with.
Parameters
- callback: ParseFn
  Parser function to transform the input value
Returns this
This schema instance for method chaining
Example
```
vine.string().parse((value) => {
  return typeof value === 'string' ? value.trim() : value
})
```
Inherited from BaseType.parse
- Defined in src/schema/base/main.ts:511

use

use(validation: Validation<any> | RuleBuilder): this
Push a validation to the validations chain.
Parameters
- validation: Validation<any> | RuleBuilder
  Validation rule or rule builder to add
Returns this
This schema instance for method chaining
Example
```
vine.string().use(vine.createRule((value) => {
  return value.length > 0
}))
```
Inherited from BaseType.use
- Defined in src/schema/base/main.ts:527

bail

bail(state: boolean): VineObject<Properties, Input, Output, CamelCaseOutput>
Enable/disable the bail mode. In bail mode, the field validations are stopped after the first error.
Parameters
- state: boolean
  Whether to enable bail mode
Returns VineObject<Properties, Input, Output, CamelCaseOutput>
This schema instance for method chaining
Inherited from BaseType.bail
- Defined in src/schema/base/main.ts:539

optional

optional(): OptionalModifier<
VineObject<Properties, Input, Output, CamelCaseOutput>,
>
Mark the field under validation as optional. An optional field allows both null and undefined values.

Returns OptionalModifier<VineObject<Properties, Input, Output, CamelCaseOutput>>
A new OptionalModifier wrapping this schema
Inherited from BaseType.optional
- Defined in src/schema/base/main.ts:550

nullable

nullable(): NullableModifier<
VineObject<Properties, Input, Output, CamelCaseOutput>,
>
Mark the field under validation to be null. The null value will be written to the output as well.

If optional and nullable are used together, then both undefined and null values will be allowed.

Returns NullableModifier<VineObject<Properties, Input, Output, CamelCaseOutput>>
A new NullableModifier wrapping this schema
Inherited from BaseType.nullable
- Defined in src/schema/base/main.ts:563

[IS_OF_TYPE]

"[IS_OF_TYPE]"(value: unknown): boolean
Type checker function to determine if a value is an object. Required for "unionOfTypes" functionality.
Parameters
- value: unknown
  The value to check
Returns boolean
True if the value is a non-null object and not an array
- Defined in src/schema/object/main.ts:180

getProperties

getProperties(): Properties
Returns a cloned copy of all object properties with their validation schemas. Note: Object groups are not included to keep implementations simple.

Returns Properties
Cloned properties record
Example
```
const properties = schema.getProperties()
```
- Defined in src/schema/object/main.ts:211

pick

pick<Keys extends string | number | symbol>(
keys: Keys[] | readonly Keys[],
): Pick<Properties, Keys>
Returns a cloned subset of object properties containing only the specified keys.
Type Parameters
- Keys extends string | number | symbol
Parameters
- keys: Keys[] | readonly Keys[]
  Array of property keys to include
Returns Pick<Properties, Keys>
Picked properties record
Example
```
const userSchema = vine.object({
  name: vine.string(),
  email: vine.string().email(),
  password: vine.string()
})

const publicFields = userSchema.pick(['name', 'email'])
```
- Defined in src/schema/object/main.ts:235

omit

omit<Keys extends string | number | symbol>(
keys: Keys[] | readonly Keys[],
): Omit<Properties, Keys>
Returns a cloned copy of object properties excluding the specified keys.
Type Parameters
- Keys extends string | number | symbol
Parameters
- keys: Keys[] | readonly Keys[]
  Array of property keys to exclude
Returns Omit<Properties, Keys>
Omitted properties record
Example
```
const userSchema = vine.object({
  name: vine.string(),
  email: vine.string().email(),
  password: vine.string()
})

const withoutPassword = userSchema.omit(['password'])
```
- Defined in src/schema/object/main.ts:258

allowUnknownProperties

allowUnknownProperties<Value>(): VineObject<
    Properties,
    Input & { [K: string]: Value },
    Output & { [K: string]: Value },
    CamelCaseOutput & { [K: string]: Value },
>
Allows unknown properties to pass through validation and be included in the output. By default, objects with properties not defined in the schema will fail validation.
Type Parameters
- Value
Returns VineObject<
    Properties,
    Input & { [K: string]: Value },
    Output & { [K: string]: Value },
    CamelCaseOutput & { [K: string]: Value },
>
This object schema with unknown properties allowed
Example
```
const schema = vine.object({
  name: vine.string()
}).allowUnknownProperties()

// Now { name: 'John', extra: 'value' } will pass validation
```
- Defined in src/schema/object/main.ts:283

merge

merge<Group extends ObjectGroup<GroupConditional<any, any, any, any>>>(
    group: Group,
): VineObject<
    Properties,
    Input & Group[typeof ITYPE],
    Output & Group[typeof OTYPE],
    CamelCaseOutput & Group[typeof COTYPE],
>
Merges conditional property groups into the object schema. Groups allow adding properties dynamically based on runtime conditions.
Type Parameters
- Group extends ObjectGroup<GroupConditional<any, any, any, any>>
Parameters
- group: Group
  The conditional group to merge
Returns VineObject<
    Properties,
    Input & Group[typeof ITYPE],
    Output & Group[typeof OTYPE],
    CamelCaseOutput & Group[typeof COTYPE],
>
This object schema with the group merged
Example
```
const schema = vine.object({
  type: vine.string()
}).merge(
  vine.group([
    vine.group.if('type', 'user', { name: vine.string() }),
    vine.group.if('type', 'admin', { permissions: vine.array(vine.string()) })
  ])
)
```
- Defined in src/schema/object/main.ts:315

clone

clone(): this
Clones the VineObject schema including all properties, validations, groups, and options.

Returns this
A cloned instance of this VineObject schema
Overrides BaseType.clone
- Defined in src/schema/object/main.ts:337

toCamelCase

toCamelCase(): VineCamelCaseObject<
VineObject<Properties, Input, Output, CamelCaseOutput>,
>
Converts object property names to camelCase in the validation output. Useful when accepting snake_case input but wanting camelCase output.

Returns VineCamelCaseObject<VineObject<Properties, Input, Output, CamelCaseOutput>>
A VineCamelCaseObject wrapper for this schema
Example
```
const schema = vine.object({
  first_name: vine.string(),
  last_name: vine.string()
}).toCamelCase()

// Output: { firstName: string, lastName: string }
```
- Defined in src/schema/object/main.ts:366

toJSONSchema

toJSONSchema(): JSONSchema7
Converts the object schema to JSON Schema format.

Returns JSONSchema7
JSON Schema representation of this object
Implementation of WithJSONSchema.toJSONSchema
Overrides BaseType.toJSONSchema
- Defined in src/schema/object/main.ts:375

partial

partial<
    Keys extends string
    | number
    | symbol = keyof Properties,
    T extends
        Record<string, SchemaTypes> = Omit<Properties, Keys> & PropertiesToOptional<
        Pick<Properties, Keys>,
    >,
>(
    keys?: Keys[] | readonly Keys[],
): VineObject<
    { [K in string
    | number
    | symbol]: T[K] },
    {
        [K in string | number | symbol]: (
            {
                [K in string
                | number
                | symbol]?: { [K in string | number | symbol]: T[K][typeof ITYPE] }[K]
            } & {
                [K in string
                | number
                | symbol]: { [K in string | number | symbol]: T[K][typeof ITYPE] }[K]
            }
        )[K]
    },
    {
        [K in string
        | number
        | symbol]: (
            {
                [K in string
                | number
                | symbol]?: { [K in string | number | symbol]: T[K][typeof OTYPE] }[K]
            } & {
                [K in string
                | number
                | symbol]: { [K in string | number | symbol]: T[K][typeof OTYPE] }[K]
            }
        )[K]
    },
    {
        [K in string
        | number
        | symbol]: (
            {
                [K in string
                | number
                | symbol]?: {
                    [K in string | number | symbol as CamelCase<K & string>]: T[K][typeof COTYPE]
                }[K]
            } & {
                [K in string
                | number
                | symbol]: {
                    [K in string | number | symbol as CamelCase<K & string>]: T[K][typeof COTYPE]
                }[K]
            }
        )[K]
    },
>
Creates a new object schema with all properties (or specified properties) marked as optional. This is useful for update/PATCH operations where not all fields are required.
Type Parameters
- Keys extends string | number | symbol = keyof Properties
- T extends Record<string, SchemaTypes> = Omit<Properties, Keys> & PropertiesToOptional<Pick<Properties, Keys>>
Parameters
- Optionalkeys: Keys[] | readonly Keys[]
  Optional array of property keys to make optional. If omitted, all properties become optional.
Returns VineObject<
    { [K in string
    | number
    | symbol]: T[K] },
    {
        [K in string | number | symbol]: (
            {
                [K in string
                | number
                | symbol]?: { [K in string | number | symbol]: T[K][typeof ITYPE] }[K]
            } & {
                [K in string
                | number
                | symbol]: { [K in string | number | symbol]: T[K][typeof ITYPE] }[K]
            }
        )[K]
    },
    {
        [K in string
        | number
        | symbol]: (
            {
                [K in string
                | number
                | symbol]?: { [K in string | number | symbol]: T[K][typeof OTYPE] }[K]
            } & {
                [K in string
                | number
                | symbol]: { [K in string | number | symbol]: T[K][typeof OTYPE] }[K]
            }
        )[K]
    },
    {
        [K in string
        | number
        | symbol]: (
            {
                [K in string
                | number
                | symbol]?: {
                    [K in string | number | symbol as CamelCase<K & string>]: T[K][typeof COTYPE]
                }[K]
            } & {
                [K in string
                | number
                | symbol]: {
                    [K in string | number | symbol as CamelCase<K & string>]: T[K][typeof COTYPE]
                }[K]
            }
        )[K]
    },
>
A new VineObject schema with optional properties
Example
```
// Make all properties optional
const updateSchema = createSchema.partial()
```
Example
```
// Make only specific properties optional
const userSchema = vine.object({
  name: vine.string(),
  email: vine.string().email(),
  age: vine.number()
})

const updateUserSchema = userSchema.partial(['name', 'age'])
// email remains required, name and age become optional
```
- Defined in src/schema/object/main.ts:437

[PARSE]

"[PARSE]"(
    propertyName: string,
    refs: RefsStore,
    options: ParserOptions,
): ObjectNode
Compiles the schema type to a compiler node for validation.
Parameters
- propertyName: string
  Name of the property being compiled
- refs: RefsStore
  Reference store for the compiler
- options: ParserOptions
  Parser options
Returns ObjectNode
Compiled object node for validation
Overrides BaseType.[PARSE]
- Defined in src/schema/object/main.ts:503

Class VineObject<Properties, Input, Output, CamelCaseOutput>

Example

Type Parameters

Hierarchy (View Summary)

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Type Parameters

Parameters

Returns VineObject<Properties, Input, Output, CamelCaseOutput>

Throws

Properties

[ITYPE]

[OTYPE]

[COTYPE]

[UNIQUE_NAME]

Methods

parse

Parameters

Returns this

Example

use

Parameters

Returns this

Example

bail

Parameters

Returns VineObject<Properties, Input, Output, CamelCaseOutput>

optional

Returns OptionalModifier<VineObject<Properties, Input, Output, CamelCaseOutput>>

nullable

Returns NullableModifier<VineObject<Properties, Input, Output, CamelCaseOutput>>

meta

Parameters

Returns MetaModifier<VineObject<Properties, Input, Output, CamelCaseOutput>>

[IS_OF_TYPE]

Parameters

Returns boolean

getProperties

Returns Properties

Example

pick

Type Parameters

Parameters

Returns Pick<Properties, Keys>

Example

omit

Type Parameters

Parameters

Returns Omit<Properties, Keys>

Example

allowUnknownProperties

Type Parameters

Returns VineObject< Properties, Input & { [K: string]: Value }, Output & { [K: string]: Value }, CamelCaseOutput & { [K: string]: Value },>

Example

merge

Type Parameters

Parameters

Returns VineObject< Properties, Input & Group[typeof ITYPE], Output & Group[typeof OTYPE], CamelCaseOutput & Group[typeof COTYPE],>

Example

clone

Returns this

toCamelCase

Returns VineCamelCaseObject<VineObject<Properties, Input, Output, CamelCaseOutput>>

Example

toJSONSchema

Returns JSONSchema7

partial

Type Parameters

Parameters

Example

Example

[PARSE]

Parameters

Returns ObjectNode

Settings

Returns VineObject<
Properties,
Input & { [K: string]: Value },
Output & { [K: string]: Value },
CamelCaseOutput & { [K: string]: Value },
>

Returns VineObject<
Properties,
Input & Group[typeof ITYPE],
Output & Group[typeof OTYPE],
CamelCaseOutput & Group[typeof COTYPE],
>