index.mdx

title	description	contributors
Other	This guide explains other special schema functions such as `literal`, `instance`, `custom` and `lazy` that are not covered in the other guides.	fabian-hiller

import { Link } from '@builder.io/qwik-city';

Other

This guide explains other special schema functions such as literal, instance, custom and lazy that are not covered in the other guides.

Literal schema

You can use literal to define a schema that matches a specific string, number or boolean value. Therefore, this schema is perfect for representing literal types. Usage is simple, just pass the value you want to match as the first argument.

import * as v from 'valibot';

const StringLiteralSchema = v.literal('foo'); // 'foo'
const NumberLiteralSchema = v.literal(12345); // 12345
const BooleanLiteralSchema = v.literal(true); // true

Instance schema

With schema functions like blob, date, map and set I already cover the most common JavaScript classes. However, there are many more classes that you may want to validate. For this purpose, you can use the instance schema function. It takes a class as its first argument and returns a schema that matches only instances of that class.

import * as v from 'valibot';

const ErrorSchema = v.instance(Error); // Error
const FileSchema = v.instance(File); // File

Custom schema

The custom schema function is a bit more advanced. It allows you to define a schema that matches a value based on a custom function. Use it whenever you need to define a schema that cannot be expressed using any of the other schema functions.

The function receives the value to validate as its first argument and must return a boolean value. If the function returns true, the value is considered valid. Otherwise, it is considered invalid.

import * as v from 'valibot';

const PixelStringSchema = v.custom<`${number}px`>((input) =>
  typeof input === 'string' ? /^\d+px$/.test(input) : false
);

Lazy schema

The lazy schema function allows you to define recursive schemas. A recursive schema is a schema that references itself. For example, you can use it to define a schema for a tree-like data structure.

Due to a TypeScript limitation, the input and output types cannot be inferred automatically in this case. Therefore, you must explicitly specify these types using the GenericSchema type.

import * as v from 'valibot';

type BinaryTree = {
  element: string;
  left: BinaryTree | null;
  right: BinaryTree | null;
};

const BinaryTreeSchema: v.GenericSchema<BinaryTree> = v.object({
  element: v.string(),
  left: v.nullable(v.lazy(() => BinaryTreeSchema)),
  right: v.nullable(v.lazy(() => BinaryTreeSchema)),
});