@dzeio/schema 0.0.1

package/dist/Schema.d.mts

@@ -0,0 +1,332 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type> {
+    '~standard': StandardSchemaV1.Props<Type>;
+    /**
+     * keep public ?
+     */
+    validations: Array<{
+        fn: (input: Type) => boolean;
+        error?: string | undefined;
+    }>;
+    /**
+     * Function calls saved for serialization
+     */
+    savedCalls: Array<{
+        name: string;
+        args: Array<string> | IArguments | undefined;
+    }>;
+    /**
+     * Pre process the variable for various reasons
+     *
+     * It will execute every pre-process sequentially in order of being added
+     *
+     * note: The type of the final Pre-Process MUST be valid
+     */
+    preProcess: Array<(input: unknown) => Type | unknown>;
+    /**
+     * post process the variable after it being validated
+     *
+     * it will execute each post-processes sequentially
+     *
+     * note: the type of the final post-process MUST be valid
+     */
+    postProcess: Array<(input: Type) => Type>;
+    /**
+     * list of attributes for custom works
+     */
+    readonly attributes: Array<string>;
+    private readonly items?;
+    private invalidError;
+    constructor(items?: Array<unknown> | IArguments);
+    attrs(...attributes: Array<string>): this;
+    attr(...attributes: Array<string>): this;
+    setInvalidError(err: string): this;
+    clone(): this;
+    /**
+     * schemas implementing unwrap can return their child component (mostly the value)
+     *
+     * ex: s.record(s.number(), s.string()) returns s.string()
+     *
+     * es2: s.nullable(s.string()) returns s.string()
+     */
+    unwrap?(): SchemaItem;
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<Type>;
+    toJSON(): SchemaJSON;
+    protected addValidation(fn: ((input: Type) => boolean) | {
+        fn: (input: Type) => boolean;
+        error?: string;
+    }, error?: string): this;
+    protected addPreProcess(fn: (input: unknown) => Type | unknown): this;
+    protected addPostProcess(fn: (input: Type) => Type): this;
+    abstract isOfType(input: unknown): input is Type;
+}
+
+type SchemaInfer<Type extends SchemaItem> = Type extends SchemaItem<infer X> ? X : never
+type Infer<Type extends SchemaItem> = SchemaInfer<Type>
+
+interface ValidationError {
+	message: string
+	field?: string
+	value?: unknown
+}
+
+type ValidationResult<T> = {
+	object: T
+	valid: true
+	errors?: undefined
+} | {
+	valid: false
+	object?: (T extends object ? Partial<T> : T) | undefined
+	errors: Array<ValidationError>
+}
+
+interface SchemaJSON {
+	i: string
+	a?: Array<string> | undefined
+	c?: Array<unknown> | undefined
+	f?: Array<{
+		n: string
+		a?: Array<unknown> | undefined
+	}> | undefined
+}
+
+/**
+* @deprecated use `SchemaJSON`
+*/
+type SchemaItemJSON = SchemaJSON
+
+/**
+* @deprecated use `Record<string, SchemaItem>`
+*/
+type Model = Record<string, SchemaItem>
+
+/**
+* @deprecated
+*/
+type ModelInfer$1<M extends Model> = {
+	[key in keyof M]: SchemaInfer<M[key]>
+}
+
+declare class SchemaDate extends SchemaItem<Date> {
+    isOfType(input: unknown): input is Date;
+}
+
+declare class SchemaRecord<Keys extends SchemaItem, Values extends SchemaItem> extends SchemaItem<Record<SchemaInfer<Keys>, SchemaInfer<Values>>> {
+    private readonly keys;
+    private readonly values;
+    constructor(keys: Keys, values: Values);
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<Record<SchemaInfer<Keys>, SchemaInfer<Values>>>;
+    isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
+}
+
+declare class SchemaArray<Type extends SchemaItem> extends SchemaItem<Array<SchemaInfer<Type>>> {
+    readonly values: Type;
+    constructor(values: Type);
+    /**
+     * transform the array so it only contains one of each elements
+     */
+    unique(): this;
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<Array<SchemaInfer<Type>>>;
+    unwrap(): Type;
+    isOfType(input: unknown): input is Array<SchemaInfer<Type>>;
+}
+
+declare class SchemaBoolean extends SchemaItem<boolean> {
+    /**
+     * @param [trueValue='true'] the truhty value (default to `'true'`)
+     * @param [falseValue='false'] the falthy value (default to `'false'`)
+     */
+    parseString(trueValue?: string, falseValue?: string): this;
+    isOfType(input: unknown): input is boolean;
+}
+
+interface EnumLike {
+    [k: string]: string | number;
+    [n: number]: string;
+}
+declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
+    private templateEnum;
+    private type;
+    constructor(templateEnum: E);
+    isOfType(input: unknown): input is E[keyof E];
+}
+
+declare class SchemaLiteral<Type> extends SchemaItem<Type> {
+    private readonly value;
+    constructor(value: Type);
+    isOfType(input: unknown): input is Type;
+}
+
+declare class SchemaNullable<Type extends SchemaItem> extends SchemaItem<SchemaInfer<Type> | undefined> {
+    readonly child: Type;
+    constructor(child: Type);
+    unwrap(): Type;
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<SchemaInfer<Type> | undefined>;
+    isOfType(input: unknown): input is SchemaInfer<Type> | undefined;
+    private isNull;
+}
+
+declare class SchemaNumber extends SchemaItem<number> {
+    /**
+     * validate that the number is less or equal than {@link value}
+     * @param value the maxumum value (inclusive)
+     * @param message the message sent if not valid
+     */
+    lte(value: number, message?: string): this;
+    /**
+     * validate that the number is more or equal than {@link value}
+     * @param value the minimum value (inclusive)
+     * @param message the message sent if not valid
+     */
+    gte(value: number, message?: string): this;
+    /**
+     * validate that the number is less than {@link value}
+     * @param value the maxumum value (exclusive)
+     * @param message the message sent if not valid
+     */
+    lt(value: number, message?: string): this;
+    /**
+     * validate that the number is more than {@link value}
+     * @param value the minimum value (exclusive)
+     * @param message the message sent if not valid
+     */
+    gt(value: number, message?: string): this;
+    /**
+     * Try to parse strings before validating
+     */
+    parseString(): this;
+    isOfType(input: unknown): input is number;
+    min(...params: Parameters<SchemaNumber['gte']>): this;
+    max(...params: Parameters<SchemaNumber['lte']>): this;
+}
+
+type ModelInfer<M extends Record<string, SchemaItem>> = {
+    [key in keyof M]: SchemaInfer<M[key]>;
+};
+declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends SchemaItem<ModelInfer<T>> {
+    readonly model: T;
+    id: string;
+    constructor(model: T);
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<ModelInfer<T>>;
+    isOfType(input: unknown): input is ModelInfer<T>;
+}
+
+declare class SchemaString extends SchemaItem<string> {
+    /**
+     * force the input text to be a minimum of `value` size
+     * @param value the minimum length of the text
+     * @param message the message to display on an error
+     */
+    min(value: number, message?: string): this;
+    /**
+     * transform the final text to the defined casing
+     * @param casing the final casing
+     */
+    toCasing(casing: 'lower' | 'upper'): this;
+    /**
+     * force the input text to be a maximum of `value` size
+     * @param value the maximum length of the text
+     * @param message the message to display on an error
+     */
+    max(value: number, message?: string): this;
+    /**
+     * the value must not be empty (`''`)
+     * @param message
+     * @returns
+     */
+    notEmpty(message?: string): this;
+    /**
+     * force the input text to respect a Regexp
+     * @param regex the regex to validate against
+     * @param message the message to display on an error
+     */
+    regex(regex: RegExp, message?: string): this;
+    minLength(value: number, message?: string): this;
+    maxLength(value: number, message?: string): this;
+    isOfType(input: unknown): input is string;
+}
+
+type ItemType<T extends Array<SchemaItem>> = SchemaInfer<T[number]>;
+declare class SchemaUnion<T extends Array<SchemaItem>> extends SchemaItem<ItemType<T>> {
+    private schemas;
+    constructor(...schemas: T);
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<SchemaInfer<T[number]>>;
+    isOfType(input: unknown): input is ItemType<T>;
+}
+
+declare function parseQuery<T extends SchemaItem>(model: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+declare function parseFormData<T extends SchemaObject>(model: T, data: FormData, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+declare function parseForm<T extends SchemaObject>(model: T, form: HTMLFormElement, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+
+declare function parceable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
+type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
+declare const Types: {
+    readonly Array: typeof SchemaArray;
+    readonly Boolean: typeof SchemaBoolean;
+    readonly Date: typeof SchemaDate;
+    readonly Enum: typeof SchemaEnum;
+    readonly Literal: typeof SchemaLiteral;
+    readonly Nullable: typeof SchemaNullable;
+    readonly Object: typeof SchemaObject;
+    readonly Record: typeof SchemaRecord;
+    readonly String: typeof SchemaString;
+    readonly Union: typeof SchemaUnion;
+};
+declare class Schema<T extends Record<string, SchemaItem> = Record<string, SchemaItem>> extends SchemaObject<T> {
+    private static registeredModules;
+    static register(module: SchemaItemStatic): void;
+    static getModule(name: string): SchemaItemStatic | undefined;
+    static array<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaArray<Type>>): SchemaArray<Type>;
+    static boolean(...inputs: ConstructorParameters<typeof SchemaBoolean>): SchemaBoolean;
+    static date(...inputs: ConstructorParameters<typeof SchemaDate>): SchemaDate;
+    static enum<Type extends EnumLike>(...inputs: ConstructorParameters<typeof SchemaEnum<Type>>): SchemaEnum<Type>;
+    /**
+    *
+    * @param input the literal value (note: append `as const` else the typing won't work correctly)
+    * @returns
+    */
+    static literal<Type>(input: Type): SchemaLiteral<Type>;
+    static nullable<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaNullable<Type>>): SchemaNullable<Type>;
+    static number(...inputs: ConstructorParameters<typeof SchemaNumber>): SchemaNumber;
+    static object<Type extends Record<string, SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaObject<Type>>): SchemaObject<Type>;
+    static record<Keys extends SchemaItem, Values extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaRecord<Keys, Values>>): SchemaRecord<Keys, Values>;
+    /**
+     * See {@link SchemaString}
+     */
+    static string(...inputs: ConstructorParameters<typeof SchemaString>): SchemaString;
+    static union<Type extends Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaUnion<Type>>): SchemaUnion<Type>;
+    static fromJSON(json: SchemaJSON): SchemaItem;
+    static isSchemaJSON(data: unknown): data is SchemaJSON;
+    /**
+     * @deprecated use helper `parseQuery`
+     */
+    validateQuery(query: URLSearchParams, fast?: boolean): ReturnType<this["parse"]>;
+    /**
+    * @deprecated use `parse`
+    */
+    validate(input: unknown, fast?: boolean): ValidationResult<{ [key in keyof T]: SchemaInfer<T[key]>; }>;
+    /**
+     * @deprecated use helper `parseForm`
+     */
+    validateForm(form: HTMLFormElement, fast?: boolean): ReturnType<this["parse"]>;
+    /**
+     * @deprecated use helper `parseFormData`
+     */
+    validateFormData(data: FormData, fast?: boolean): ReturnType<this["parse"]>;
+}
+declare const s: typeof Schema;
+
+export { type Infer, type Model, type ModelInfer$1 as ModelInfer, SchemaArray, SchemaBoolean, SchemaDate, SchemaEnum, type SchemaInfer, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNullable, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUnion, Types, type ValidationError, type ValidationResult, Schema as default, parceable, parseForm, parseFormData, parseQuery, s };

package/dist/Schema.d.ts

@@ -0,0 +1,332 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type> {
+    '~standard': StandardSchemaV1.Props<Type>;
+    /**
+     * keep public ?
+     */
+    validations: Array<{
+        fn: (input: Type) => boolean;
+        error?: string | undefined;
+    }>;
+    /**
+     * Function calls saved for serialization
+     */
+    savedCalls: Array<{
+        name: string;
+        args: Array<string> | IArguments | undefined;
+    }>;
+    /**
+     * Pre process the variable for various reasons
+     *
+     * It will execute every pre-process sequentially in order of being added
+     *
+     * note: The type of the final Pre-Process MUST be valid
+     */
+    preProcess: Array<(input: unknown) => Type | unknown>;
+    /**
+     * post process the variable after it being validated
+     *
+     * it will execute each post-processes sequentially
+     *
+     * note: the type of the final post-process MUST be valid
+     */
+    postProcess: Array<(input: Type) => Type>;
+    /**
+     * list of attributes for custom works
+     */
+    readonly attributes: Array<string>;
+    private readonly items?;
+    private invalidError;
+    constructor(items?: Array<unknown> | IArguments);
+    attrs(...attributes: Array<string>): this;
+    attr(...attributes: Array<string>): this;
+    setInvalidError(err: string): this;
+    clone(): this;
+    /**
+     * schemas implementing unwrap can return their child component (mostly the value)
+     *
+     * ex: s.record(s.number(), s.string()) returns s.string()
+     *
+     * es2: s.nullable(s.string()) returns s.string()
+     */
+    unwrap?(): SchemaItem;
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<Type>;
+    toJSON(): SchemaJSON;
+    protected addValidation(fn: ((input: Type) => boolean) | {
+        fn: (input: Type) => boolean;
+        error?: string;
+    }, error?: string): this;
+    protected addPreProcess(fn: (input: unknown) => Type | unknown): this;
+    protected addPostProcess(fn: (input: Type) => Type): this;
+    abstract isOfType(input: unknown): input is Type;
+}
+
+type SchemaInfer<Type extends SchemaItem> = Type extends SchemaItem<infer X> ? X : never
+type Infer<Type extends SchemaItem> = SchemaInfer<Type>
+
+interface ValidationError {
+	message: string
+	field?: string
+	value?: unknown
+}
+
+type ValidationResult<T> = {
+	object: T
+	valid: true
+	errors?: undefined
+} | {
+	valid: false
+	object?: (T extends object ? Partial<T> : T) | undefined
+	errors: Array<ValidationError>
+}
+
+interface SchemaJSON {
+	i: string
+	a?: Array<string> | undefined
+	c?: Array<unknown> | undefined
+	f?: Array<{
+		n: string
+		a?: Array<unknown> | undefined
+	}> | undefined
+}
+
+/**
+* @deprecated use `SchemaJSON`
+*/
+type SchemaItemJSON = SchemaJSON
+
+/**
+* @deprecated use `Record<string, SchemaItem>`
+*/
+type Model = Record<string, SchemaItem>
+
+/**
+* @deprecated
+*/
+type ModelInfer$1<M extends Model> = {
+	[key in keyof M]: SchemaInfer<M[key]>
+}
+
+declare class SchemaDate extends SchemaItem<Date> {
+    isOfType(input: unknown): input is Date;
+}
+
+declare class SchemaRecord<Keys extends SchemaItem, Values extends SchemaItem> extends SchemaItem<Record<SchemaInfer<Keys>, SchemaInfer<Values>>> {
+    private readonly keys;
+    private readonly values;
+    constructor(keys: Keys, values: Values);
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<Record<SchemaInfer<Keys>, SchemaInfer<Values>>>;
+    isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
+}
+
+declare class SchemaArray<Type extends SchemaItem> extends SchemaItem<Array<SchemaInfer<Type>>> {
+    readonly values: Type;
+    constructor(values: Type);
+    /**
+     * transform the array so it only contains one of each elements
+     */
+    unique(): this;
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<Array<SchemaInfer<Type>>>;
+    unwrap(): Type;
+    isOfType(input: unknown): input is Array<SchemaInfer<Type>>;
+}
+
+declare class SchemaBoolean extends SchemaItem<boolean> {
+    /**
+     * @param [trueValue='true'] the truhty value (default to `'true'`)
+     * @param [falseValue='false'] the falthy value (default to `'false'`)
+     */
+    parseString(trueValue?: string, falseValue?: string): this;
+    isOfType(input: unknown): input is boolean;
+}
+
+interface EnumLike {
+    [k: string]: string | number;
+    [n: number]: string;
+}
+declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
+    private templateEnum;
+    private type;
+    constructor(templateEnum: E);
+    isOfType(input: unknown): input is E[keyof E];
+}
+
+declare class SchemaLiteral<Type> extends SchemaItem<Type> {
+    private readonly value;
+    constructor(value: Type);
+    isOfType(input: unknown): input is Type;
+}
+
+declare class SchemaNullable<Type extends SchemaItem> extends SchemaItem<SchemaInfer<Type> | undefined> {
+    readonly child: Type;
+    constructor(child: Type);
+    unwrap(): Type;
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<SchemaInfer<Type> | undefined>;
+    isOfType(input: unknown): input is SchemaInfer<Type> | undefined;
+    private isNull;
+}
+
+declare class SchemaNumber extends SchemaItem<number> {
+    /**
+     * validate that the number is less or equal than {@link value}
+     * @param value the maxumum value (inclusive)
+     * @param message the message sent if not valid
+     */
+    lte(value: number, message?: string): this;
+    /**
+     * validate that the number is more or equal than {@link value}
+     * @param value the minimum value (inclusive)
+     * @param message the message sent if not valid
+     */
+    gte(value: number, message?: string): this;
+    /**
+     * validate that the number is less than {@link value}
+     * @param value the maxumum value (exclusive)
+     * @param message the message sent if not valid
+     */
+    lt(value: number, message?: string): this;
+    /**
+     * validate that the number is more than {@link value}
+     * @param value the minimum value (exclusive)
+     * @param message the message sent if not valid
+     */
+    gt(value: number, message?: string): this;
+    /**
+     * Try to parse strings before validating
+     */
+    parseString(): this;
+    isOfType(input: unknown): input is number;
+    min(...params: Parameters<SchemaNumber['gte']>): this;
+    max(...params: Parameters<SchemaNumber['lte']>): this;
+}
+
+type ModelInfer<M extends Record<string, SchemaItem>> = {
+    [key in keyof M]: SchemaInfer<M[key]>;
+};
+declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends SchemaItem<ModelInfer<T>> {
+    readonly model: T;
+    id: string;
+    constructor(model: T);
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<ModelInfer<T>>;
+    isOfType(input: unknown): input is ModelInfer<T>;
+}
+
+declare class SchemaString extends SchemaItem<string> {
+    /**
+     * force the input text to be a minimum of `value` size
+     * @param value the minimum length of the text
+     * @param message the message to display on an error
+     */
+    min(value: number, message?: string): this;
+    /**
+     * transform the final text to the defined casing
+     * @param casing the final casing
+     */
+    toCasing(casing: 'lower' | 'upper'): this;
+    /**
+     * force the input text to be a maximum of `value` size
+     * @param value the maximum length of the text
+     * @param message the message to display on an error
+     */
+    max(value: number, message?: string): this;
+    /**
+     * the value must not be empty (`''`)
+     * @param message
+     * @returns
+     */
+    notEmpty(message?: string): this;
+    /**
+     * force the input text to respect a Regexp
+     * @param regex the regex to validate against
+     * @param message the message to display on an error
+     */
+    regex(regex: RegExp, message?: string): this;
+    minLength(value: number, message?: string): this;
+    maxLength(value: number, message?: string): this;
+    isOfType(input: unknown): input is string;
+}
+
+type ItemType<T extends Array<SchemaItem>> = SchemaInfer<T[number]>;
+declare class SchemaUnion<T extends Array<SchemaItem>> extends SchemaItem<ItemType<T>> {
+    private schemas;
+    constructor(...schemas: T);
+    parse(input: unknown, options?: {
+        fast?: boolean;
+    }): ValidationResult<SchemaInfer<T[number]>>;
+    isOfType(input: unknown): input is ItemType<T>;
+}
+
+declare function parseQuery<T extends SchemaItem>(model: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+declare function parseFormData<T extends SchemaObject>(model: T, data: FormData, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+declare function parseForm<T extends SchemaObject>(model: T, form: HTMLFormElement, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+
+declare function parceable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
+type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
+declare const Types: {
+    readonly Array: typeof SchemaArray;
+    readonly Boolean: typeof SchemaBoolean;
+    readonly Date: typeof SchemaDate;
+    readonly Enum: typeof SchemaEnum;
+    readonly Literal: typeof SchemaLiteral;
+    readonly Nullable: typeof SchemaNullable;
+    readonly Object: typeof SchemaObject;
+    readonly Record: typeof SchemaRecord;
+    readonly String: typeof SchemaString;
+    readonly Union: typeof SchemaUnion;
+};
+declare class Schema<T extends Record<string, SchemaItem> = Record<string, SchemaItem>> extends SchemaObject<T> {
+    private static registeredModules;
+    static register(module: SchemaItemStatic): void;
+    static getModule(name: string): SchemaItemStatic | undefined;
+    static array<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaArray<Type>>): SchemaArray<Type>;
+    static boolean(...inputs: ConstructorParameters<typeof SchemaBoolean>): SchemaBoolean;
+    static date(...inputs: ConstructorParameters<typeof SchemaDate>): SchemaDate;
+    static enum<Type extends EnumLike>(...inputs: ConstructorParameters<typeof SchemaEnum<Type>>): SchemaEnum<Type>;
+    /**
+    *
+    * @param input the literal value (note: append `as const` else the typing won't work correctly)
+    * @returns
+    */
+    static literal<Type>(input: Type): SchemaLiteral<Type>;
+    static nullable<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaNullable<Type>>): SchemaNullable<Type>;
+    static number(...inputs: ConstructorParameters<typeof SchemaNumber>): SchemaNumber;
+    static object<Type extends Record<string, SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaObject<Type>>): SchemaObject<Type>;
+    static record<Keys extends SchemaItem, Values extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaRecord<Keys, Values>>): SchemaRecord<Keys, Values>;
+    /**
+     * See {@link SchemaString}
+     */
+    static string(...inputs: ConstructorParameters<typeof SchemaString>): SchemaString;
+    static union<Type extends Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaUnion<Type>>): SchemaUnion<Type>;
+    static fromJSON(json: SchemaJSON): SchemaItem;
+    static isSchemaJSON(data: unknown): data is SchemaJSON;
+    /**
+     * @deprecated use helper `parseQuery`
+     */
+    validateQuery(query: URLSearchParams, fast?: boolean): ReturnType<this["parse"]>;
+    /**
+    * @deprecated use `parse`
+    */
+    validate(input: unknown, fast?: boolean): ValidationResult<{ [key in keyof T]: SchemaInfer<T[key]>; }>;
+    /**
+     * @deprecated use helper `parseForm`
+     */
+    validateForm(form: HTMLFormElement, fast?: boolean): ReturnType<this["parse"]>;
+    /**
+     * @deprecated use helper `parseFormData`
+     */
+    validateFormData(data: FormData, fast?: boolean): ReturnType<this["parse"]>;
+}
+declare const s: typeof Schema;
+
+export { type Infer, type Model, type ModelInfer$1 as ModelInfer, SchemaArray, SchemaBoolean, SchemaDate, SchemaEnum, type SchemaInfer, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNullable, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUnion, Types, type ValidationError, type ValidationResult, Schema as default, parceable, parseForm, parseFormData, parseQuery, s };