/** The Standard Schema interface. */
export interface StandardSchemaV1;
}
export declare namespace StandardSchemaV1 {
/** The Standard Schema properties interface. */
export interface Props | Promise>;
/** Inferred types associated with the schema. */
readonly types?: Types | undefined;
}
/** The result interface of the validate function. */
export type Result = SuccessResult | FailureResult;
/** The result interface if validation succeeds. */
export interface SuccessResult {
/** The typed output value. */
readonly value: Output;
/** The non-existent issues. */
readonly issues?: undefined;
}
/** The result interface if validation fails. */
export interface FailureResult {
/** The issues of failed validation. */
readonly issues: ReadonlyArray;
}
/** The issue interface of the failure output. */
export interface Issue {
/** The error message of the issue. */
readonly message: string;
/** The path of the issue, if any. */
readonly path?: ReadonlyArray | undefined;
}
/** The path segment interface of the issue. */
export interface PathSegment {
/** The key representing a path segment. */
readonly key: PropertyKey;
}
/** The Standard Schema types interface. */
export interface Types = NonNullable<
Schema["~standard"]["types"]
>["input"];
/** Infers the output type of a Standard Schema. */
export type InferOutput = NonNullable<
Schema["~standard"]["types"]
>["output"];
}
export type SuccessResult = {
readonly success: true;
readonly value: Value;
readonly error?: undefined;
};
export type FailureResult = {
readonly success: false;
readonly error: Error;
};
export type Result = SuccessResult | FailureResult;
export type JSON =
| string
| boolean
| number
| null
| { [key: string]: JSON }
| JSON[];
export type NumberFormat = "int32" | "port";
export type StringFormat = "json" | "date-time" | "email" | "uuid" | "cuid" | "url";
export type ArrayFormat = "compactColumns";
export type Format = NumberFormat | StringFormat | ArrayFormat;
export type Schema = {
with(
to: (
schema: Schema,
target: Schema,
decode?: ((value: unknown) => unknown) | undefined,
encode?: (value: unknown) => Output
) => Schema,
target: Schema,
decode?: ((value: Output) => TargetInput) | undefined,
encode?: (value: TargetInput) => Output
): Schema;
with(
refine: (
schema: Schema,
refineCheck: (value: unknown) => boolean,
refineOptions?: { error?: string; path?: string[] }
) => Schema,
refineCheck: (value: Output) => boolean,
refineOptions?: { error?: string; path?: string[] }
): Schema;
// I don't know how, but it makes both S.refine and S.shape work
with(
fn: (
schema: Schema,
callback: ((value: unknown) => unknown) | undefined
) => Schema,
callback: ((value: Output) => Shape) | undefined
): Schema;
// with(message: string): t; TODO: implement
with(fn: (schema: Schema) => Schema): Schema;
with(
fn: (schema: Schema, arg1: A1) => Schema,
arg1: A1
): Schema;
with(
fn: (schema: Schema, arg1: A1) => Schema,
arg1: A1
): Schema;
with(
fn: (schema: Schema, arg1: A1, arg2: A2) => Schema,
arg1: A1,
arg2: A2
): Schema;
readonly $defs?: Record>;
readonly name?: string;
readonly title?: string;
readonly description?: string;
readonly deprecated?: boolean;
readonly examples?: Input[];
readonly noValidation?: boolean;
readonly default?: Input;
readonly to?: Schema;
readonly errorMessage?: SchemaErrorMessage;
readonly ["~standard"]: StandardSchemaV1.Props;
} & (
| {
readonly type: "never";
}
| {
readonly type: "unknown";
}
| {
readonly type: "string";
readonly format?: StringFormat;
readonly const?: string;
readonly minLength?: number;
readonly maxLength?: number;
readonly pattern?: RegExp;
}
| {
readonly type: "number";
readonly format?: NumberFormat;
readonly const?: number;
readonly minimum?: number;
readonly maximum?: number;
}
| {
readonly type: "bigint";
readonly const?: bigint;
}
| {
readonly type: "boolean";
readonly const?: boolean;
}
| {
readonly type: "symbol";
readonly const?: symbol;
}
| {
readonly type: "null";
readonly const: null;
}
| {
readonly type: "undefined";
readonly const: undefined;
}
| {
readonly type: "nan";
readonly const: number;
}
| {
readonly type: "function";
readonly const?: Input;
}
| {
readonly type: "instance";
readonly class: Class;
readonly additionalItems: "strip" | "strict" | Schema;
readonly format?: ArrayFormat;
readonly minItems?: number;
readonly maxItems?: number;
}
| {
readonly type: "object";
readonly properties: {
[key: string]: Schema;
};
readonly additionalItems: "strip" | "strict" | Schema;
readonly required?: string[];
}
| {
readonly type: "union";
readonly anyOf: Schema[];
readonly has: Record<
| "string"
| "number"
| "never"
| "unknown"
| "bigint"
| "boolean"
| "symbol"
| "null"
| "undefined"
| "nan"
| "function"
| "instance"
| "array"
| "object",
boolean
>;
}
| {
readonly type: "ref";
readonly $ref: string;
}
);
export abstract class Path {
protected opaque: any;
} /* simulate opaque types */
export type Error =
| {
readonly code: "invalid_input";
readonly path: Path;
readonly message: string;
readonly reason: string;
readonly expected: Schema;
readonly received: Schema;
readonly input?: unknown;
readonly unionErrors?: readonly Error[];
}
| {
readonly code: "invalid_operation";
readonly path: Path;
readonly message: string;
readonly reason: string;
}
| {
readonly code: "unsupported_decode";
readonly path: Path;
readonly message: string;
readonly reason: string;
readonly from: Schema;
readonly to: Schema;
}
| {
readonly code: "invalid_conversion";
readonly path: Path;
readonly message: string;
readonly reason: string;
readonly from: Schema;
readonly to: Schema;
readonly cause?: Error;
}
| {
readonly code: "unrecognized_keys";
readonly path: Path;
readonly message: string;
readonly reason: string;
readonly keys: readonly string[];
};
export const Error: {
new (): Error;
prototype: Error;
};
// Extract Output/Input by matching only the `~standard` marker instead of the
// full `Schema<…>` shape (whose 14-member union + `with` overloads are costly to
// instantiate per match). `types` is optional, so the pattern keeps it optional.
export type Output = T extends {
readonly ["~standard"]: { readonly types?: { readonly output: infer Output } };
}
? Output
: never;
export type Infer = Output;
export type Input = T extends {
readonly ["~standard"]: { readonly types?: { readonly input: infer Input } };
}
? Input
: never;
// Utility types for decoder function with multiple schemas
type ExtractFirstInput[]> =
T extends readonly [Schema, ...any[]]
? FirstInput
: never;
// Utility types for encoder function with multiple schemas
type ExtractFirstOutput[]> =
T extends readonly [Schema, ...any[]]
? FirstOutput
: never;
type ExtractLastOutput[]> =
T extends readonly [...any[], Schema]
? LastOutput
: T extends readonly [Schema]
? SingleOutput
: never;
type ExtractLastInput[]> =
T extends readonly [...any[], Schema]
? LastInput
: T extends readonly [Schema]
? SingleInput
: never;
export type UnknownToOutput = T extends Schema
? Output
: T extends (...args: any[]) => any
? T
: T extends unknown[]
? { [K in keyof T]: UnknownToOutput }
: T extends { [k in keyof T]: unknown }
? ResolveObject<{ [K in keyof T]: UnknownToOutput }>
: T;
export type UnknownToInput = T extends Schema
? Input
: T extends (...args: any[]) => any
? T
: T extends unknown[]
? { [K in keyof T]: UnknownToInput }
: T extends { [k in keyof T]: unknown }
? ResolveObject<{ [K in keyof T]: UnknownToInput }>
: T;
export type Brand = T & {
/**
* TypeScript won't suggest strings beginning with a space as properties.
* Useful for symbol-like string properties.
*/
readonly [" brand"]: [T, ID];
};
export function brand(
schema: Schema,
brandId: ID
): Schema, Input>;
// `R` already holds each field's resolved type. A field is optional iff its type
// admits `undefined`, so an `S.never` field stays required. The split is skipped
// when no field is optional.
type ResolveObject = undefined extends R[keyof R]
? Flatten<
{
[K in keyof R as undefined extends R[K] ? K : never]?: R[K];
} & {
[K in keyof R as undefined extends R[K] ? never : K]: R[K];
}
>
: Flatten;
// Flatten an intersection into one object, keeping values verbatim (incl. `never`).
type Flatten = T extends object ? { [K in keyof T]: T[K] } : T;
type UnknownArrayToOutput<
T extends unknown[],
Length extends number = T["length"]
> = Length extends Length
? number extends Length
? T
: _RestToOutput
: never;
type _RestToOutput<
T extends unknown[],
Length extends number,
Accumulated extends unknown[],
Index extends number = Accumulated["length"]
> = Index extends Length
? Accumulated
: _RestToOutput]>;
type UnknownArrayToInput<
T extends unknown[],
Length extends number = T["length"]
> = Length extends Length
? number extends Length
? T
: _RestToInput
: never;
type _RestToInput<
T extends unknown[],
Length extends number,
Accumulated extends unknown[],
Index extends number = Accumulated["length"]
> = Index extends Length
? Accumulated
: _RestToInput]>;
type Literal =
| string
| number
| boolean
| symbol
| bigint
| undefined
| null
| []
| Schema;
export function schema(
value: T
): Schema, UnknownToInput>;
export function schema(
schemas: [...T]
): Schema<[...UnknownArrayToOutput], [...UnknownArrayToInput]>;
export function schema(
schemas: [...T]
): Schema<[...UnknownArrayToOutput], [...UnknownArrayToInput]>;
export function schema(
value: T
): Schema, UnknownToInput>;
export function union(
schemas: [A, ...B]
): Schema<
UnknownToOutput | UnknownArrayToOutput[number],
UnknownToInput | UnknownArrayToInput[number]
>;
export function union(
schemas: [A, ...B]
): Schema<
UnknownToOutput | UnknownArrayToOutput[number],
UnknownToInput | UnknownArrayToInput[number]
>;
export function union(
schemas: readonly T[]
): Schema, UnknownToInput>;
export const string: Schema;
export const boolean: Schema;
export const int32: Schema;
export const number: Schema;
export const bigint: Schema;
export const symbol: Schema;
export const never: Schema;
export const unknown: Schema;
export const any: Schema;
declare const void_: Schema;
export { void_ as void };
export const json: Schema;
export const jsonString: Schema;
export const jsonStringWithSpace: (space: number) => Schema;
export const uint8Array: Schema;
export const isoDateTime: Schema;
export const port: Schema;
export const email: Schema;
export const uuid: Schema;
export const cuid: Schema;
export const url: Schema;
export const date: Schema;
export function safe(scope: () => Value): Result;
export function safeAsync(
scope: () => Promise
): Promise>;
export function reverse(
schema: Schema
): Schema;
export function parser(
schema: Schema
): (data: unknown) => Output;
export function parser(
from: Schema,
target: Schema
): (data: unknown) => Output;
export function parser<
Schemas extends readonly [Schema, ...Schema[]]
>(...schemas: Schemas): (data: unknown) => ExtractLastOutput;
export function asyncParser(
schema: Schema
): (data: unknown) => Promise;
export function asyncParser(
from: Schema,
target: Schema
): (data: unknown) => Promise;
export function asyncParser<
Schemas extends readonly [Schema, ...Schema[]]
>(...schemas: Schemas): (data: unknown) => Promise>;
export function decoder(
schema: Schema
): (data: Input) => Output;
export function decoder(
from: Schema,
target: Schema
): (data: Input) => Output;
export function decoder<
Schemas extends readonly [Schema, ...Schema[]]
>(
...schemas: Schemas
): (data: ExtractFirstInput) => ExtractLastOutput;
export function asyncDecoder(
schema: Schema
): (data: Input) => Promise;
export function asyncDecoder(
from: Schema,
target: Schema
): (data: Input) => Promise;
export function decoder<
Schemas extends readonly [Schema, ...Schema[]]
>(
...schemas: Schemas
): (data: ExtractFirstInput) => Promise>;
export function encoder(
schema: Schema
): (data: Output) => Input;
export function encoder(
from: Schema,
target: Schema
): (data: Output) => Input;
export function encoder<
Schemas extends readonly [Schema, ...Schema[]]
>(
...schemas: Schemas
): (data: ExtractFirstOutput) => ExtractLastInput;
export function asyncEncoder(
schema: Schema
): (data: Output) => Promise(
from: Schema,
target: Schema
): (data: Output) => Promise, ...Schema[]]
>(
...schemas: Schemas
): (data: ExtractFirstOutput) => Promise>;
export function assert(
schema: Schema,
data: unknown
): asserts data is Input;
export function assert(
data: unknown,
schema: Schema
): asserts data is Input;
export function is(
schema: Schema,
data: unknown
): data is Input;
export function is(
data: unknown,
schema: Schema
): data is Input;
export function tuple(
definer: (s: {
item: (
inputIndex: number,
schema: Schema
) => ItemOutput;
tag: (inputIndex: number, value: unknown) => void;
}) => Output
): Schema;
export function optional<
Output,
Input,
Or extends Output | undefined = undefined
>(
schema: Schema,
or?: (() => Or) | Or,
// To make .with work
_?: never
): Schema<
Or extends undefined ? Output | undefined : Output,
Input | undefined
>;
export function nullable<
Output,
Input,
Or extends Output | null = null
>(
schema: Schema,
or?: (() => Or) | Or,
// To make .with work
_?: never
): Schema;
export const nullish: (
schema: Schema
) => Schema;
export type Class = new (...args: readonly any[]) => T;
export const instance: (class_: Class) => Schema;
export const array: (
schema: Schema
) => Schema;
export const compactColumns: (
schema: Schema
) => Schema;
export const record: (
schema: Schema
) => Schema, Record>;
type ObjectCtx(
name: string,
schema: Schema
) => FieldOutput;
fieldOr: (
name: string,
schema: Schema,
or: FieldOutput
) => FieldOutput;
tag: (
name: TagName,
value: Input[TagName]
) => void;
flatten: (schema: Schema) => FieldOutput;
nested: (name: string) => ObjectCtx>;
};
export function object>(
definer: (ctx: ObjectCtx;
export function strip>(
schema: Schema
): Schema;
export function deepStrip>(
schema: Schema
): Schema;
export function strict>(
schema: Schema
): Schema