@vertz/schema 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,782 @@
+declare enum ErrorCode {
+	InvalidType = "invalid_type",
+	TooSmall = "too_small",
+	TooBig = "too_big",
+	InvalidString = "invalid_string",
+	InvalidEnumValue = "invalid_enum_value",
+	InvalidLiteral = "invalid_literal",
+	InvalidUnion = "invalid_union",
+	InvalidDate = "invalid_date",
+	MissingProperty = "missing_property",
+	UnrecognizedKeys = "unrecognized_keys",
+	Custom = "custom",
+	InvalidIntersection = "invalid_intersection",
+	NotMultipleOf = "not_multiple_of",
+	NotFinite = "not_finite"
+}
+interface ValidationIssue {
+	code: ErrorCode;
+	message: string;
+	path: (string | number)[];
+	expected?: string;
+	received?: string;
+}
+declare class ParseError extends Error {
+	readonly issues: ValidationIssue[];
+	constructor(issues: ValidationIssue[]);
+	static formatMessage(issues: ValidationIssue[]): string;
+}
+declare class ParseContext {
+	readonly issues: ValidationIssue[];
+	private _path;
+	addIssue(issue: Omit<ValidationIssue, "path"> & {
+		path?: (string | number)[];
+	}): void;
+	hasIssues(): boolean;
+	pushPath(segment: string | number): void;
+	popPath(): void;
+	get path(): (string | number)[];
+}
+/** Public-facing refinement context — subset of ParseContext exposed to .refine()/.superRefine()/.check() */
+interface RefinementContext {
+	addIssue(issue: Omit<ValidationIssue, "path"> & {
+		path?: (string | number)[];
+	}): void;
+	readonly path: (string | number)[];
+}
+interface JSONSchemaObject {
+	[key: string]: unknown;
+}
+declare class RefTracker {
+	private _seen;
+	private _defs;
+	hasSeen(id: string): boolean;
+	markSeen(id: string): void;
+	addDef(id: string, schema: JSONSchemaObject): void;
+	getDefs(): Record<string, JSONSchemaObject>;
+}
+declare function toJSONSchema2(schema: SchemaAny): JSONSchemaObject;
+declare enum SchemaType {
+	String = "string",
+	Number = "number",
+	BigInt = "bigint",
+	Boolean = "boolean",
+	Date = "date",
+	Symbol = "symbol",
+	Undefined = "undefined",
+	Null = "null",
+	Void = "void",
+	Any = "any",
+	Unknown = "unknown",
+	Never = "never",
+	NaN = "nan",
+	Object = "object",
+	Array = "array",
+	Tuple = "tuple",
+	Enum = "enum",
+	Union = "union",
+	DiscriminatedUnion = "discriminatedUnion",
+	Intersection = "intersection",
+	Record = "record",
+	Map = "map",
+	Set = "set",
+	Literal = "literal",
+	Lazy = "lazy",
+	Custom = "custom",
+	InstanceOf = "instanceof",
+	File = "file"
+}
+interface SchemaMetadata {
+	type: SchemaType;
+	id: string | undefined;
+	description: string | undefined;
+	meta: Record<string, unknown> | undefined;
+	examples: unknown[];
+}
+type SafeParseResult<T> = {
+	success: true;
+	data: T;
+} | {
+	success: false;
+	error: ParseError;
+};
+type SchemaAny = Schema<any, any>;
+/** Apply Readonly only to object types; leave primitives and `any` unchanged. */
+type ReadonlyOutput<O> = 0 extends 1 & O ? O : O extends object ? Readonly<O> : O;
+type InnerSchema<I = unknown> = Schema<any, I>;
+type InnerTransformFn<O> = (value: any) => O;
+declare abstract class Schema<
+	O,
+	I = O
+> {
+	/** @internal */ readonly _output: O;
+	/** @internal */ readonly _input: I;
+	/** @internal */ _id: string | undefined;
+	/** @internal */ _description: string | undefined;
+	/** @internal */ _meta: Record<string, unknown> | undefined;
+	/** @internal */ _examples: unknown[];
+	constructor();
+	abstract _schemaType(): SchemaType;
+	abstract _toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	abstract _clone(): Schema<O, I>;
+	parse(value: unknown): O;
+	safeParse(value: unknown): SafeParseResult<O>;
+	id(name: string): this;
+	describe(description: string): this;
+	meta(data: Record<string, unknown>): this;
+	example(value: I): this;
+	get metadata(): SchemaMetadata;
+	toJSONSchema(): JSONSchemaObject;
+	_toJSONSchemaWithRefs(tracker: RefTracker): JSONSchemaObject;
+	private _applyMetadata;
+	protected _cloneBase<T extends {
+		_id: string | undefined;
+		_description: string | undefined;
+		_meta: Record<string, unknown> | undefined;
+		_examples: unknown[];
+	}>(target: T): T;
+	optional(): OptionalSchema<O, I>;
+	nullable(): NullableSchema<O, I>;
+	default(defaultValue: I | (() => I)): DefaultSchema<O, I>;
+	refine(predicate: (value: O) => boolean, params?: string | {
+		message?: string;
+		path?: (string | number)[];
+	}): RefinedSchema<O, I>;
+	superRefine(refinement: (value: O, ctx: RefinementContext) => void): SuperRefinedSchema<O, I>;
+	check(refinement: (value: O, ctx: RefinementContext) => void): SuperRefinedSchema<O, I>;
+	transform<NewO>(fn: (value: O) => NewO): TransformSchema<NewO, I>;
+	pipe<NewO>(schema: Schema<NewO>): PipeSchema<NewO, I>;
+	catch(fallback: O | (() => O)): CatchSchema<O, I>;
+	brand<B extends string | symbol>(): BrandedSchema<O & {
+		readonly __brand: B;
+	}, I>;
+	readonly(): ReadonlySchema<ReadonlyOutput<O>, I>;
+	_runPipeline(value: unknown, ctx: ParseContext): O;
+}
+declare class OptionalSchema<
+	O,
+	I
+> extends Schema<O | undefined, I | undefined> {
+	private readonly _inner;
+	constructor(_inner: Schema<O, I>);
+	_schemaType(): SchemaType;
+	_parse(value: unknown, ctx: ParseContext): O | undefined;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): OptionalSchema<O, I>;
+	unwrap(): Schema<O, I>;
+}
+declare class NullableSchema<
+	O,
+	I
+> extends Schema<O | null, I | null> {
+	private readonly _inner;
+	constructor(_inner: Schema<O, I>);
+	_schemaType(): SchemaType;
+	_parse(value: unknown, ctx: ParseContext): O | null;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): NullableSchema<O, I>;
+	unwrap(): Schema<O, I>;
+}
+declare class DefaultSchema<
+	O,
+	I
+> extends Schema<O, I | undefined> {
+	private readonly _inner;
+	private readonly _default;
+	constructor(_inner: Schema<O, I>, _default: I | (() => I));
+	_schemaType(): SchemaType;
+	_parse(value: unknown, ctx: ParseContext): O;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	private _resolveDefault;
+	_clone(): DefaultSchema<O, I>;
+	unwrap(): Schema<O, I>;
+}
+declare class RefinedSchema<
+	O,
+	I = O
+> extends Schema<O, I> {
+	private readonly _inner;
+	private readonly _predicate;
+	private readonly _message;
+	private readonly _path;
+	constructor(inner: Schema<O, I>, predicate: (value: O) => boolean, params?: string | {
+		message?: string;
+		path?: (string | number)[];
+	});
+	_parse(value: unknown, ctx: ParseContext): O;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): RefinedSchema<O, I>;
+}
+declare class SuperRefinedSchema<
+	O,
+	I = O
+> extends Schema<O, I> {
+	private readonly _inner;
+	private readonly _refinement;
+	constructor(inner: Schema<O, I>, refinement: (value: O, ctx: RefinementContext) => void);
+	_parse(value: unknown, ctx: ParseContext): O;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): SuperRefinedSchema<O, I>;
+}
+declare class TransformSchema<
+	O,
+	I = unknown
+> extends Schema<O, I> {
+	private readonly _inner;
+	private readonly _transform;
+	constructor(inner: InnerSchema<I>, transform: InnerTransformFn<O>);
+	_parse(value: unknown, ctx: ParseContext): O;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): TransformSchema<O, I>;
+}
+declare class PipeSchema<
+	O,
+	I = unknown
+> extends Schema<O, I> {
+	private readonly _first;
+	private readonly _second;
+	constructor(first: InnerSchema<I>, second: Schema<O>);
+	_parse(value: unknown, ctx: ParseContext): O;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): PipeSchema<O, I>;
+}
+declare class CatchSchema<
+	O,
+	I = O
+> extends Schema<O, I> {
+	private readonly _inner;
+	private readonly _fallback;
+	constructor(inner: Schema<O, I>, fallback: O | (() => O));
+	_parse(value: unknown, _ctx: ParseContext): O;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	private _resolveFallback;
+	_clone(): CatchSchema<O, I>;
+}
+declare class BrandedSchema<
+	O,
+	I = unknown
+> extends Schema<O, I> {
+	private readonly _inner;
+	constructor(inner: InnerSchema<I>);
+	_parse(value: unknown, ctx: ParseContext): O;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): BrandedSchema<O, I>;
+}
+declare class ReadonlySchema<
+	O,
+	I = unknown
+> extends Schema<O, I> {
+	private readonly _inner;
+	constructor(inner: InnerSchema<I>);
+	_parse(value: unknown, ctx: ParseContext): O;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): ReadonlySchema<O, I>;
+}
+declare class SchemaRegistry {
+	private static _schemas;
+	static register(name: string, schema: SchemaAny): void;
+	static get(name: string): SchemaAny | undefined;
+	static getOrThrow(name: string): SchemaAny;
+	static has(name: string): boolean;
+	/** Returns a read-only view of the internal map. Do not cast to Map to mutate. */
+	static getAll(): ReadonlyMap<string, SchemaAny>;
+	static clear(): void;
+}
+declare class ArraySchema<T> extends Schema<T[]> {
+	private readonly _element;
+	private _min;
+	private _max;
+	private _length;
+	constructor(element: Schema<T>);
+	_parse(value: unknown, ctx: ParseContext): T[];
+	min(n: number): ArraySchema<T>;
+	max(n: number): ArraySchema<T>;
+	length(n: number): ArraySchema<T>;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): ArraySchema<T>;
+}
+declare class BigIntSchema extends Schema<bigint> {
+	_parse(value: unknown, ctx: ParseContext): bigint;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): BigIntSchema;
+}
+declare class BooleanSchema extends Schema<boolean> {
+	_parse(value: unknown, ctx: ParseContext): boolean;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): BooleanSchema;
+}
+declare class DateSchema extends Schema<Date> {
+	private _min;
+	private _minMessage;
+	private _max;
+	private _maxMessage;
+	_parse(value: unknown, ctx: ParseContext): Date;
+	min(date: Date, message?: string): DateSchema;
+	max(date: Date, message?: string): DateSchema;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): DateSchema;
+}
+declare class NumberSchema extends Schema<number> {
+	private _gte;
+	private _gteMessage;
+	private _gt;
+	private _gtMessage;
+	private _lte;
+	private _lteMessage;
+	private _lt;
+	private _ltMessage;
+	private _int;
+	private _positive;
+	private _negative;
+	private _nonnegative;
+	private _nonpositive;
+	private _multipleOf;
+	private _finite;
+	_parse(value: unknown, ctx: ParseContext): number;
+	gte(n: number, message?: string): NumberSchema;
+	min(n: number, message?: string): NumberSchema;
+	gt(n: number, message?: string): NumberSchema;
+	lte(n: number, message?: string): NumberSchema;
+	max(n: number, message?: string): NumberSchema;
+	lt(n: number, message?: string): NumberSchema;
+	int(): NumberSchema;
+	positive(): NumberSchema;
+	negative(): NumberSchema;
+	nonnegative(): NumberSchema;
+	nonpositive(): NumberSchema;
+	multipleOf(n: number): NumberSchema;
+	step(n: number): NumberSchema;
+	finite(): NumberSchema;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): NumberSchema;
+}
+declare class StringSchema extends Schema<string> {
+	private _min;
+	private _minMessage;
+	private _max;
+	private _maxMessage;
+	private _length;
+	private _lengthMessage;
+	private _regex;
+	private _startsWith;
+	private _endsWith;
+	private _includes;
+	private _uppercase;
+	private _lowercase;
+	private _trim;
+	private _toLowerCase;
+	private _toUpperCase;
+	private _normalize;
+	_parse(value: unknown, ctx: ParseContext): string;
+	min(n: number, message?: string): StringSchema;
+	max(n: number, message?: string): StringSchema;
+	length(n: number, message?: string): StringSchema;
+	regex(pattern: RegExp): StringSchema;
+	startsWith(prefix: string): StringSchema;
+	endsWith(suffix: string): StringSchema;
+	includes(substring: string): StringSchema;
+	uppercase(): StringSchema;
+	lowercase(): StringSchema;
+	trim(): StringSchema;
+	toLowerCase(): StringSchema;
+	toUpperCase(): StringSchema;
+	normalize(): StringSchema;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): StringSchema;
+}
+declare class CoercedStringSchema extends StringSchema {
+	_parse(value: unknown, ctx: ParseContext): string;
+	_clone(): CoercedStringSchema;
+}
+declare class CoercedNumberSchema extends NumberSchema {
+	_parse(value: unknown, ctx: ParseContext): number;
+	_clone(): CoercedNumberSchema;
+}
+declare class CoercedBooleanSchema extends BooleanSchema {
+	_parse(value: unknown, ctx: ParseContext): boolean;
+	_clone(): CoercedBooleanSchema;
+}
+declare class CoercedBigIntSchema extends BigIntSchema {
+	_parse(value: unknown, ctx: ParseContext): bigint;
+	_clone(): CoercedBigIntSchema;
+}
+declare class CoercedDateSchema extends DateSchema {
+	_parse(value: unknown, ctx: ParseContext): Date;
+	_clone(): CoercedDateSchema;
+}
+declare class CustomSchema<T> extends Schema<T> {
+	private readonly _check;
+	private readonly _message;
+	constructor(check: (value: unknown) => boolean, message?: string);
+	_parse(value: unknown, ctx: ParseContext): T;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): CustomSchema<T>;
+}
+type Shape = Record<string, SchemaAny>;
+type InferShape<S extends Shape> = { [K in keyof S] : S[K]["_output"] };
+declare class ObjectSchema<S extends Shape = Shape> extends Schema<InferShape<S>> {
+	private readonly _shape;
+	private _unknownKeys;
+	private _catchall;
+	constructor(shape: S);
+	get shape(): S;
+	private _isOptionalKey;
+	_parse(value: unknown, ctx: ParseContext): InferShape<S>;
+	strict(): ObjectSchema<S>;
+	passthrough(): ObjectSchema<S>;
+	extend<E extends Shape>(extension: E): ObjectSchema<S & E>;
+	merge<O extends Shape>(other: ObjectSchema<O>): ObjectSchema<Omit<S, keyof O> & O>;
+	pick<K extends keyof S & string>(...keys: K[]): ObjectSchema<Pick<S, K>>;
+	required(): ObjectSchema<{ [K in keyof S] : S[K] extends OptionalSchema<infer O, infer I> ? Schema<O, I> : S[K] extends DefaultSchema<infer O, infer I> ? Schema<O, I> : S[K] }>;
+	partial(): ObjectSchema<{ [K in keyof S] : OptionalSchema<S[K]["_output"], S[K]["_input"]> } & Shape>;
+	omit<K extends keyof S & string>(...keys: K[]): ObjectSchema<Omit<S, K>>;
+	keyof(): string[];
+	catchall(schema: SchemaAny): ObjectSchema<S>;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): ObjectSchema<S>;
+}
+type DiscriminatedOptions = [ObjectSchema<any>, ...ObjectSchema<any>[]];
+type InferDiscriminatedUnion<T extends DiscriminatedOptions> = T[number] extends infer U ? U extends Schema<infer O> ? O : never : never;
+declare class DiscriminatedUnionSchema<T extends DiscriminatedOptions> extends Schema<InferDiscriminatedUnion<T>> {
+	private readonly _discriminator;
+	private readonly _options;
+	private readonly _lookup;
+	constructor(discriminator: string, options: T);
+	_parse(value: unknown, ctx: ParseContext): InferDiscriminatedUnion<T>;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): DiscriminatedUnionSchema<T>;
+}
+declare class EnumSchema<T extends readonly [string, ...string[]]> extends Schema<T[number]> {
+	private readonly _values;
+	constructor(values: T);
+	_parse(value: unknown, ctx: ParseContext): T[number];
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	exclude<E extends T[number]>(values: E[]): EnumSchema<readonly [string, ...string[]]>;
+	extract<E extends T[number]>(values: E[]): EnumSchema<readonly [string, ...string[]]>;
+	_clone(): EnumSchema<T>;
+}
+declare class FileSchema extends Schema<Blob> {
+	_parse(value: unknown, ctx: ParseContext): Blob;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): FileSchema;
+}
+declare abstract class FormatSchema extends StringSchema {
+	protected abstract _errorMessage: string;
+	protected abstract _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown> | undefined;
+	_parse(value: unknown, ctx: ParseContext): string;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): this;
+}
+declare class Base64Schema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class CuidSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+}
+declare class EmailSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class HexSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class HostnameSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class Ipv4Schema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class Ipv6Schema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class IsoDateSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class IsoTimeSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class IsoDatetimeSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class IsoDurationSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class JwtSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+}
+declare class NanoidSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+}
+declare class UlidSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+}
+declare class UrlSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+declare class UuidSchema extends FormatSchema {
+	protected _errorMessage: string;
+	protected _validate(value: string): boolean;
+	protected _jsonSchemaExtra(): Record<string, unknown>;
+}
+type Constructor<T> = new (...args: any[]) => T;
+declare class InstanceOfSchema<T> extends Schema<T> {
+	private readonly _cls;
+	constructor(cls: Constructor<T>);
+	_parse(value: unknown, ctx: ParseContext): T;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): InstanceOfSchema<T>;
+}
+declare class IntersectionSchema<
+	L extends SchemaAny,
+	R extends SchemaAny
+> extends Schema<L["_output"] & R["_output"]> {
+	private readonly _left;
+	private readonly _right;
+	constructor(left: L, right: R);
+	_parse(value: unknown, ctx: ParseContext): L["_output"] & R["_output"];
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): IntersectionSchema<L, R>;
+}
+declare class LazySchema<T> extends Schema<T> {
+	private readonly _getter;
+	private _cached;
+	constructor(getter: () => Schema<T>);
+	private _resolve;
+	_parse(value: unknown, ctx: ParseContext): T;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): LazySchema<T>;
+}
+type LiteralValue = string | number | boolean | null;
+declare class LiteralSchema<T extends LiteralValue> extends Schema<T> {
+	private readonly _value;
+	constructor(value: T);
+	get value(): T;
+	_parse(value: unknown, ctx: ParseContext): T;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): LiteralSchema<T>;
+}
+declare class MapSchema<
+	K,
+	V
+> extends Schema<Map<K, V>> {
+	private readonly _keySchema;
+	private readonly _valueSchema;
+	constructor(keySchema: Schema<K>, valueSchema: Schema<V>);
+	_parse(value: unknown, ctx: ParseContext): Map<K, V>;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): MapSchema<K, V>;
+}
+declare class NanSchema extends Schema<number> {
+	_parse(value: unknown, ctx: ParseContext): number;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): NanSchema;
+}
+declare class RecordSchema<V> extends Schema<Record<string, V>> {
+	private readonly _keySchema;
+	private readonly _valueSchema;
+	constructor(valueSchema: Schema<V>);
+	constructor(keySchema: Schema<string>, valueSchema: Schema<V>);
+	_parse(value: unknown, ctx: ParseContext): Record<string, V>;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): RecordSchema<V>;
+}
+declare class SetSchema<V> extends Schema<Set<V>> {
+	private readonly _valueSchema;
+	private _min;
+	private _max;
+	private _size;
+	constructor(valueSchema: Schema<V>);
+	_parse(value: unknown, ctx: ParseContext): Set<V>;
+	min(n: number): SetSchema<V>;
+	max(n: number): SetSchema<V>;
+	size(n: number): SetSchema<V>;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): SetSchema<V>;
+}
+declare class AnySchema extends Schema<any> {
+	_parse(value: unknown, _ctx: ParseContext): any;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): AnySchema;
+}
+declare class UnknownSchema extends Schema<unknown> {
+	_parse(value: unknown, _ctx: ParseContext): unknown;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): UnknownSchema;
+}
+declare class NullSchema extends Schema<null> {
+	_parse(value: unknown, ctx: ParseContext): null;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): NullSchema;
+}
+declare class UndefinedSchema extends Schema<undefined> {
+	_parse(value: unknown, ctx: ParseContext): undefined;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): UndefinedSchema;
+}
+declare class VoidSchema extends Schema<void> {
+	_parse(value: unknown, ctx: ParseContext): void;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): VoidSchema;
+}
+declare class NeverSchema extends Schema<never> {
+	_parse(value: unknown, ctx: ParseContext): never;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): NeverSchema;
+}
+declare class SymbolSchema extends Schema<symbol> {
+	_parse(value: unknown, ctx: ParseContext): symbol;
+	_schemaType(): SchemaType;
+	_toJSONSchema(_tracker: RefTracker): JSONSchemaObject;
+	_clone(): SymbolSchema;
+}
+type TupleItems = [SchemaAny, ...SchemaAny[]];
+type InferTuple<T extends TupleItems> = { [K in keyof T] : T[K] extends Schema<infer O> ? O : never };
+declare class TupleSchema<T extends TupleItems> extends Schema<InferTuple<T>> {
+	private readonly _items;
+	private _rest;
+	constructor(items: T);
+	_parse(value: unknown, ctx: ParseContext): InferTuple<T>;
+	rest<R>(schema: Schema<R>): TupleSchema<T>;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): TupleSchema<T>;
+}
+type UnionOptions = [SchemaAny, ...SchemaAny[]];
+type InferUnion<T extends UnionOptions> = T[number] extends infer U ? U extends Schema<infer O> ? O : never : never;
+declare class UnionSchema<T extends UnionOptions> extends Schema<InferUnion<T>> {
+	private readonly _options;
+	constructor(options: T);
+	_parse(value: unknown, ctx: ParseContext): InferUnion<T>;
+	_schemaType(): SchemaType;
+	_toJSONSchema(tracker: RefTracker): JSONSchemaObject;
+	_clone(): UnionSchema<T>;
+}
+declare function preprocess<O>(fn: (value: unknown) => unknown, schema: Schema<O>): Schema<O>;
+/** Infer the output type of a schema. Alias for Output<T>. */
+type Infer<T extends SchemaAny> = T["_output"];
+/** Infer the output type of a schema. */
+type Output<T extends SchemaAny> = T["_output"];
+/** Infer the input type of a schema. Differs from Output when transforms exist. */
+type Input<T extends SchemaAny> = T["_input"];
+declare const s: {
+	string: () => StringSchema;
+	number: () => NumberSchema;
+	boolean: () => BooleanSchema;
+	bigint: () => BigIntSchema;
+	date: () => DateSchema;
+	symbol: () => SymbolSchema;
+	nan: () => NanSchema;
+	int: () => NumberSchema;
+	any: () => AnySchema;
+	unknown: () => UnknownSchema;
+	null: () => NullSchema;
+	undefined: () => UndefinedSchema;
+	void: () => VoidSchema;
+	never: () => NeverSchema;
+	object: <T extends Record<string, SchemaAny>>(shape: T) => ObjectSchema<T>;
+	array: <T>(itemSchema: Schema<T>) => ArraySchema<T>;
+	tuple: <T extends [SchemaAny, ...SchemaAny[]]>(items: [...T]) => TupleSchema<T>;
+	enum: <T extends readonly [string, ...string[]]>(values: T) => EnumSchema<T>;
+	literal: <T extends string | number | boolean | null>(value: T) => LiteralSchema<T>;
+	union: <T extends [SchemaAny, ...SchemaAny[]]>(options: [...T]) => UnionSchema<T>;
+	discriminatedUnion: <T extends [ObjectSchema<any>, ...ObjectSchema<any>[]]>(discriminator: string, options: [...T]) => DiscriminatedUnionSchema<T>;
+	intersection: <
+		L extends SchemaAny,
+		R extends SchemaAny
+	>(left: L, right: R) => IntersectionSchema<L, R>;
+	record: <V>(valueSchema: Schema<V>) => RecordSchema<V>;
+	map: <
+		K,
+		V
+	>(keySchema: Schema<K>, valueSchema: Schema<V>) => MapSchema<K, V>;
+	set: <V>(valueSchema: Schema<V>) => SetSchema<V>;
+	file: () => FileSchema;
+	custom: <T>(check: (value: unknown) => boolean, message?: string) => CustomSchema<T>;
+	instanceof: <T>(cls: new (...args: any[]) => T) => InstanceOfSchema<T>;
+	lazy: <T>(getter: () => Schema<T>) => LazySchema<T>;
+	email: () => EmailSchema;
+	uuid: () => UuidSchema;
+	url: () => UrlSchema;
+	hostname: () => HostnameSchema;
+	ipv4: () => Ipv4Schema;
+	ipv6: () => Ipv6Schema;
+	base64: () => Base64Schema;
+	hex: () => HexSchema;
+	jwt: () => JwtSchema;
+	cuid: () => CuidSchema;
+	ulid: () => UlidSchema;
+	nanoid: () => NanoidSchema;
+	iso: {
+		date: () => IsoDateSchema;
+		time: () => IsoTimeSchema;
+		datetime: () => IsoDatetimeSchema;
+		duration: () => IsoDurationSchema;
+	};
+	coerce: {
+		string: () => CoercedStringSchema;
+		number: () => CoercedNumberSchema;
+		boolean: () => CoercedBooleanSchema;
+		bigint: () => CoercedBigIntSchema;
+		date: () => CoercedDateSchema;
+	};
+};
+declare const schema: typeof s;
+export { toJSONSchema2 as toJSONSchema, schema, s, preprocess, VoidSchema, ValidationIssue, UuidSchema, UrlSchema, UnknownSchema, UnionSchema, UndefinedSchema, UlidSchema, TupleSchema, TransformSchema, SymbolSchema, SuperRefinedSchema, StringSchema, SetSchema, SchemaType, SchemaRegistry, SchemaMetadata, SchemaAny, Schema, SafeParseResult, RefinementContext, RefinedSchema, RefTracker, RecordSchema, ReadonlySchema, ReadonlyOutput, PipeSchema, ParseError, ParseContext, Output, OptionalSchema, ObjectSchema, NumberSchema, NullableSchema, NullSchema, NeverSchema, NanoidSchema, NanSchema, MapSchema, LiteralSchema, LazySchema, JwtSchema, JSONSchemaObject, IsoTimeSchema, IsoDurationSchema, IsoDatetimeSchema, IsoDateSchema, Ipv6Schema, Ipv4Schema, IntersectionSchema, InstanceOfSchema, Input, Infer, HostnameSchema, HexSchema, FileSchema, ErrorCode, EnumSchema, EmailSchema, DiscriminatedUnionSchema, DefaultSchema, DateSchema, CustomSchema, CuidSchema, CoercedStringSchema, CoercedNumberSchema, CoercedDateSchema, CoercedBooleanSchema, CoercedBigIntSchema, CatchSchema, BrandedSchema, BooleanSchema, BigIntSchema, Base64Schema, ArraySchema, AnySchema };