@dzeio/schema 0.5.0 → 0.7.0

package/dist/Schema.d.mts

@@ -4,13 +4,6 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     readonly _output: Output;
     readonly _input: Input;
     '~standard': StandardSchemaV1.Props<Input, Output>;
-    /**
-     * keep public ?
-     */
-    protected readonly validations: Array<{
-        fn: (input: Output) => boolean;
-        error?: string | undefined;
-    }>;
     /**
      * Function calls saved for serialization
      */
@@ -18,6 +11,17 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
         name: string;
         args: Array<string> | IArguments | undefined;
     }>;
+    /**
+     * list of attributes for custom works
+     */
+    readonly attributes: Array<string>;
+    /**
+     * keep public ?
+     */
+    protected readonly validations: Array<{
+        fn: (input: Output) => boolean;
+        error?: string | undefined;
+    }>;
     /**
      * Pre process the variable for various reasons
      *
@@ -34,13 +38,10 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
      * note: the type of the final post-process MUST be valid
      */
     protected readonly postProcess: Array<(input: Output) => Output>;
-    /**
-     * list of attributes for custom works
-     */
-    readonly attributes: Array<string>;
     protected readonly items?: Array<unknown>;
     private invalidError;
     constructor(items?: Array<unknown> | IArguments);
+    parseJSON(): this;
     /**
     * make sure the value is one of the `values`
     * @param values the values the item MUST contains
@@ -64,6 +65,15 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
      * es2: s.nullable(s.string()) returns s.string()
      */
     unwrap?(): SchemaItem;
+    parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
+    toJSON(): SchemaJSON;
+    private deepSerializeItem;
+    addValidation(fn: ((input: Output) => boolean) | {
+        fn: (input: Output) => boolean;
+        error?: string;
+    }, error?: string): this;
+    addPreProcess(fn: (input: unknown) => Input | unknown): this;
+    addPostProcess(fn: (input: Output) => Output): this;
     /** Returns the sub values of the input, the schema item to handle them, and the path to it */
     protected getSubInputs(_input: unknown): Array<{
         item: SchemaItem;
@@ -76,21 +86,12 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
         input: unknown;
         errors?: Array<ValidationError>;
     };
-    parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
-    toJSON(): SchemaJSON;
-    addValidation(fn: ((input: Output) => boolean) | {
-        fn: (input: Output) => boolean;
-        error?: string;
-    }, error?: string): this;
-    addPreProcess(fn: (input: unknown) => Input | unknown): this;
-    addPostProcess(fn: (input: Output) => Output): this;
-    parseJSON(): this;
     abstract isOfType(input: unknown): input is Output;
 }
 
-type SchemaInfer<Type extends SchemaItem> = Type["_output"]
+type SchemaInfer<Type extends SchemaItem> = Type['_output']
 type Infer<Type extends SchemaItem> = SchemaInfer<Type>
-type SchemaInputInfer<Type extends SchemaItem> = Type["_input"]
+type SchemaInputInfer<Type extends SchemaItem> = Type['_input']
 type InputInfer<Type extends SchemaItem> = SchemaInputInfer<Type>
 
 interface ValidationOptions {
@@ -128,7 +129,7 @@ type ValidationResultOld<T> = {
  */
 interface SchemaJSON {
 	/** Id of the schema item (name of the constructor) */
-	i: string
+	_i: string
 	/** Attributes */
 	a?: Array<string> | undefined
 	/** Children schema items */
@@ -159,6 +160,8 @@ type ModelInfer$1<M extends Model> = {
 	[key in keyof M]: SchemaInfer<M[key]>
 }
 
+type Literal = string | number | bigint | boolean | null | undefined
+
 declare class SchemaAny extends SchemaItem {
     isOfType(_input: unknown): _input is any;
 }
@@ -173,11 +176,11 @@ declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Va
     private readonly keys;
     private readonly values;
     constructor(keys: Keys, values: Values);
+    isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
-        errors?: ValidationError[];
+        errors?: Array<ValidationError>;
     };
-    isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
 }
 
 declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Array<Output>, Array<Input>> {
@@ -187,18 +190,19 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
      * transform the array so it only contains one of each elements
      */
     unique(): this;
+    clean(): this;
     /**
     * split a string into an array
     * @param [separator] default:`,` the separator to use
     */
     split(separator?: string): this;
+    unwrap(): Child;
+    isOfType(input: unknown): input is Array<Output>;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
         path: string | undefined;
     }>;
-    unwrap(): Child;
-    isOfType(input: unknown): input is Array<Output>;
 }
 
 declare class SchemaBoolean extends SchemaItem<boolean> {
@@ -221,17 +225,20 @@ declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof 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 SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
+    private readonly values;
+    constructor(...values: Types);
+    isOfType(input: unknown): input is Types[number];
 }
 
 declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output | undefined, Input | null | undefined> {
     private readonly child;
     constructor(child: Child);
     falsyAsNull(): this;
+    emptyAsNull(): this;
+    emptyFileAsNull(): this;
     unwrap(): Child;
+    isOfType(input: unknown): input is Output | undefined;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
@@ -241,7 +248,6 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
         input: unknown;
         errors?: Array<ValidationError>;
     };
-    isOfType(input: unknown): input is Output | undefined;
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
@@ -285,12 +291,12 @@ declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends S
     readonly model: T;
     id: string;
     constructor(model: T);
+    isOfType(input: unknown): input is ModelInfer<T>;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
         path: string | undefined;
     }>;
-    isOfType(input: unknown): input is ModelInfer<T>;
 }
 
 declare class SchemaString extends SchemaItem<string> {
@@ -323,6 +329,11 @@ declare class SchemaString extends SchemaItem<string> {
      * @param message the message to display on an error
      */
     regex(regex: RegExp, message?: string): this;
+    /**
+     * force the input text to be an email
+     * @param message the message to display on an error
+     */
+    email(message?: string): this;
     minLength(value: number, message?: string): this;
     maxLength(value: number, message?: string): this;
     isOfType(input: unknown): input is string;
@@ -331,11 +342,11 @@ declare class SchemaString extends SchemaItem<string> {
 declare class SchemaUnion<Children extends Array<SchemaItem>, Outputs = SchemaInfer<Children[number]>, Inputs = SchemaInputInfer<Children[number]>> extends SchemaItem<Outputs, Inputs> {
     private readonly schemas;
     constructor(...schemas: Children);
+    isOfType(input: unknown): input is Outputs;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
         errors?: Array<ValidationError>;
     };
-    isOfType(input: unknown): input is Outputs;
 }
 
 type Prettify<T> = T extends unknown ? {
@@ -345,11 +356,11 @@ type UnionToIntersection<U> = (U extends U ? (x: U) => void : never) extends ((x
 declare class SchemaIntersection<Children extends Array<SchemaItem>, Outputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>, Inputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>> extends SchemaItem<Outputs, Inputs> {
     private readonly schemas;
     constructor(...schemas: Children);
+    isOfType(input: unknown): input is Outputs;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
         errors?: Array<ValidationError>;
     };
-    isOfType(input: unknown): input is Outputs;
 }
 
 declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output, Input | null | undefined> {
@@ -358,12 +369,12 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
     private readonly strict;
     constructor(child: Child, defaultVal: Output, strict?: boolean);
     unwrap(): Child;
+    isOfType(input: unknown): input is Output;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
         path: string | undefined;
     }>;
-    isOfType(input: unknown): input is Output;
 }
 
 declare class SchemaFile extends SchemaItem<File> {
@@ -373,17 +384,17 @@ declare class SchemaFile extends SchemaItem<File> {
     isOfType(input: unknown): input is File;
 }
 
-type TupleToOutputs<Tuple extends Array<SchemaItem>, Result extends any[] = []> = number extends Tuple["length"] ? Array<SchemaInfer<Tuple[number]>> : Tuple[Result["length"]] extends undefined ? Result : TupleToOutputs<Tuple, [...Result, SchemaInfer<Tuple[Result["length"]]>]>;
-type TupleToInputs<Tuple extends Array<SchemaItem>, Result extends any[] = []> = number extends Tuple["length"] ? Array<SchemaInputInfer<Tuple[number]>> : Tuple[Result["length"]] extends undefined ? Result : TupleToInputs<Tuple, [...Result, SchemaInputInfer<Tuple[Result["length"]]>]>;
+type TupleToOutputs<Tuple extends Array<SchemaItem>, Result extends Array<any> = []> = number extends Tuple['length'] ? Array<SchemaInfer<Tuple[number]>> : Tuple[Result['length']] extends undefined ? Result : TupleToOutputs<Tuple, [...Result, SchemaInfer<Tuple[Result['length']]>]>;
+type TupleToInputs<Tuple extends Array<SchemaItem>, Result extends Array<any> = []> = number extends Tuple['length'] ? Array<SchemaInputInfer<Tuple[number]>> : Tuple[Result['length']] extends undefined ? Result : TupleToInputs<Tuple, [...Result, SchemaInputInfer<Tuple[Result['length']]>]>;
 declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToOutputs<Children>, Inputs = TupleToInputs<Children>> extends SchemaItem<Outputs, Inputs> {
     private readonly children;
     constructor(...children: Children);
+    isOfType(input: unknown): input is Outputs;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
         path: string | undefined;
     }>;
-    isOfType(input: unknown): input is Outputs;
 }
 
 declare class SchemaUndefined extends SchemaItem<undefined> {
@@ -403,7 +414,10 @@ declare class SchemaNever extends SchemaItem<never> {
 }
 
 declare function isNull(value: unknown): value is undefined | null;
-declare function parseQuery<T extends SchemaItem>(model: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+declare function parseQuery<T extends SchemaItem>(schema: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+/**
+ * (Note: be carefull : missing key/value associated to schema "s.boolean().nullable" or "s.boolean()" will be transform into false)
+ */
 declare function parseFormData<T extends SchemaItem>(schema: T, data: FormData, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 
@@ -412,30 +426,10 @@ declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement
  */
 declare function parsable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
 type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
-declare const Types: {
-    readonly Any: typeof SchemaAny;
-    readonly Array: typeof SchemaArray;
-    readonly Tuple: typeof SchemaTuple;
-    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;
-    readonly Intersection: typeof SchemaIntersection;
-    readonly Default: typeof SchemaDefault;
-    readonly Undefined: typeof SchemaUndefined;
-    readonly Void: typeof SchemaVoid;
-    readonly Null: typeof SchemaNull;
-    readonly Nullish: typeof SchemaNullish;
-};
 declare class Schema<T extends Record<string, SchemaItem> = Record<string, SchemaItem>> extends SchemaObject<T> {
     private static readonly registeredModules;
     static register(module: SchemaItemStatic): void;
-    static getModule(name: string): SchemaItemStatic | undefined;
+    static getModule(name: string): SchemaItemStatic;
     static any(): SchemaAny;
     static array<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaArray<Type>>): SchemaArray<Type>;
     static boolean(...inputs: ConstructorParameters<typeof SchemaBoolean>): SchemaBoolean;
@@ -446,7 +440,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     * @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 literal<Type extends Array<Literal>>(...inputs: ConstructorParameters<typeof SchemaLiteral<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>;
@@ -457,14 +451,15 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     static string(...inputs: ConstructorParameters<typeof SchemaString>): SchemaString;
     static file(...inputs: ConstructorParameters<typeof SchemaFile>): SchemaFile;
     static union<Type extends Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaUnion<Type>>): SchemaUnion<Type>;
-    static intersection<Type extends SchemaItem[]>(...inputs: ConstructorParameters<typeof SchemaIntersection<Type>>): SchemaIntersection<Type>;
-    static tuple<Items extends SchemaItem[]>(...inputs: ConstructorParameters<typeof SchemaTuple<Items>>): SchemaTuple<Items>;
+    static intersection<Type extends Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaIntersection<Type>>): SchemaIntersection<Type>;
+    static tuple<Items extends Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaTuple<Items>>): SchemaTuple<Items>;
     static undefined(...inputs: ConstructorParameters<typeof SchemaUndefined>): SchemaUndefined;
     static null(...inputs: ConstructorParameters<typeof SchemaNull>): SchemaNull;
     static nullish(...inputs: ConstructorParameters<typeof SchemaNullish>): SchemaNullish;
     static void(...inputs: ConstructorParameters<typeof SchemaVoid>): SchemaVoid;
     static never(...inputs: ConstructorParameters<typeof SchemaNever>): SchemaNever;
     static fromJSON(json: SchemaJSON): SchemaItem;
+    static deepParseSchemaJSON(item: unknown): unknown;
     static isSchemaJSON(data: unknown): data is SchemaJSON;
     /**
      * @deprecated use helper `parseQuery`
@@ -485,4 +480,4 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
 }
 declare const s: typeof Schema;
 
-export { type Infer, type InputInfer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaDefault, SchemaEnum, SchemaFile, type SchemaInfer, type SchemaInputInfer, SchemaIntersection, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNever, SchemaNull, SchemaNullable, SchemaNullish, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUndefined, SchemaUnion, SchemaVoid, Types, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parsable, parseForm, parseFormData, parseQuery, s };
+export { type Infer, type InputInfer, type Literal, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaDefault, SchemaEnum, SchemaFile, type SchemaInfer, type SchemaInputInfer, SchemaIntersection, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNever, SchemaNull, SchemaNullable, SchemaNullish, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUndefined, SchemaUnion, SchemaVoid, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parsable, parseForm, parseFormData, parseQuery, s };

package/dist/Schema.d.ts

@@ -4,13 +4,6 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     readonly _output: Output;
     readonly _input: Input;
     '~standard': StandardSchemaV1.Props<Input, Output>;
-    /**
-     * keep public ?
-     */
-    protected readonly validations: Array<{
-        fn: (input: Output) => boolean;
-        error?: string | undefined;
-    }>;
     /**
      * Function calls saved for serialization
      */
@@ -18,6 +11,17 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
         name: string;
         args: Array<string> | IArguments | undefined;
     }>;
+    /**
+     * list of attributes for custom works
+     */
+    readonly attributes: Array<string>;
+    /**
+     * keep public ?
+     */
+    protected readonly validations: Array<{
+        fn: (input: Output) => boolean;
+        error?: string | undefined;
+    }>;
     /**
      * Pre process the variable for various reasons
      *
@@ -34,13 +38,10 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
      * note: the type of the final post-process MUST be valid
      */
     protected readonly postProcess: Array<(input: Output) => Output>;
-    /**
-     * list of attributes for custom works
-     */
-    readonly attributes: Array<string>;
     protected readonly items?: Array<unknown>;
     private invalidError;
     constructor(items?: Array<unknown> | IArguments);
+    parseJSON(): this;
     /**
     * make sure the value is one of the `values`
     * @param values the values the item MUST contains
@@ -64,6 +65,15 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
      * es2: s.nullable(s.string()) returns s.string()
      */
     unwrap?(): SchemaItem;
+    parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
+    toJSON(): SchemaJSON;
+    private deepSerializeItem;
+    addValidation(fn: ((input: Output) => boolean) | {
+        fn: (input: Output) => boolean;
+        error?: string;
+    }, error?: string): this;
+    addPreProcess(fn: (input: unknown) => Input | unknown): this;
+    addPostProcess(fn: (input: Output) => Output): this;
     /** Returns the sub values of the input, the schema item to handle them, and the path to it */
     protected getSubInputs(_input: unknown): Array<{
         item: SchemaItem;
@@ -76,21 +86,12 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
         input: unknown;
         errors?: Array<ValidationError>;
     };
-    parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
-    toJSON(): SchemaJSON;
-    addValidation(fn: ((input: Output) => boolean) | {
-        fn: (input: Output) => boolean;
-        error?: string;
-    }, error?: string): this;
-    addPreProcess(fn: (input: unknown) => Input | unknown): this;
-    addPostProcess(fn: (input: Output) => Output): this;
-    parseJSON(): this;
     abstract isOfType(input: unknown): input is Output;
 }
 
-type SchemaInfer<Type extends SchemaItem> = Type["_output"]
+type SchemaInfer<Type extends SchemaItem> = Type['_output']
 type Infer<Type extends SchemaItem> = SchemaInfer<Type>
-type SchemaInputInfer<Type extends SchemaItem> = Type["_input"]
+type SchemaInputInfer<Type extends SchemaItem> = Type['_input']
 type InputInfer<Type extends SchemaItem> = SchemaInputInfer<Type>
 
 interface ValidationOptions {
@@ -128,7 +129,7 @@ type ValidationResultOld<T> = {
  */
 interface SchemaJSON {
 	/** Id of the schema item (name of the constructor) */
-	i: string
+	_i: string
 	/** Attributes */
 	a?: Array<string> | undefined
 	/** Children schema items */
@@ -159,6 +160,8 @@ type ModelInfer$1<M extends Model> = {
 	[key in keyof M]: SchemaInfer<M[key]>
 }
 
+type Literal = string | number | bigint | boolean | null | undefined
+
 declare class SchemaAny extends SchemaItem {
     isOfType(_input: unknown): _input is any;
 }
@@ -173,11 +176,11 @@ declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Va
     private readonly keys;
     private readonly values;
     constructor(keys: Keys, values: Values);
+    isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
-        errors?: ValidationError[];
+        errors?: Array<ValidationError>;
     };
-    isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
 }
 
 declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Array<Output>, Array<Input>> {
@@ -187,18 +190,19 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
      * transform the array so it only contains one of each elements
      */
     unique(): this;
+    clean(): this;
     /**
     * split a string into an array
     * @param [separator] default:`,` the separator to use
     */
     split(separator?: string): this;
+    unwrap(): Child;
+    isOfType(input: unknown): input is Array<Output>;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
         path: string | undefined;
     }>;
-    unwrap(): Child;
-    isOfType(input: unknown): input is Array<Output>;
 }
 
 declare class SchemaBoolean extends SchemaItem<boolean> {
@@ -221,17 +225,20 @@ declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof 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 SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
+    private readonly values;
+    constructor(...values: Types);
+    isOfType(input: unknown): input is Types[number];
 }
 
 declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output | undefined, Input | null | undefined> {
     private readonly child;
     constructor(child: Child);
     falsyAsNull(): this;
+    emptyAsNull(): this;
+    emptyFileAsNull(): this;
     unwrap(): Child;
+    isOfType(input: unknown): input is Output | undefined;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
@@ -241,7 +248,6 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
         input: unknown;
         errors?: Array<ValidationError>;
     };
-    isOfType(input: unknown): input is Output | undefined;
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
@@ -285,12 +291,12 @@ declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends S
     readonly model: T;
     id: string;
     constructor(model: T);
+    isOfType(input: unknown): input is ModelInfer<T>;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
         path: string | undefined;
     }>;
-    isOfType(input: unknown): input is ModelInfer<T>;
 }
 
 declare class SchemaString extends SchemaItem<string> {
@@ -323,6 +329,11 @@ declare class SchemaString extends SchemaItem<string> {
      * @param message the message to display on an error
      */
     regex(regex: RegExp, message?: string): this;
+    /**
+     * force the input text to be an email
+     * @param message the message to display on an error
+     */
+    email(message?: string): this;
     minLength(value: number, message?: string): this;
     maxLength(value: number, message?: string): this;
     isOfType(input: unknown): input is string;
@@ -331,11 +342,11 @@ declare class SchemaString extends SchemaItem<string> {
 declare class SchemaUnion<Children extends Array<SchemaItem>, Outputs = SchemaInfer<Children[number]>, Inputs = SchemaInputInfer<Children[number]>> extends SchemaItem<Outputs, Inputs> {
     private readonly schemas;
     constructor(...schemas: Children);
+    isOfType(input: unknown): input is Outputs;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
         errors?: Array<ValidationError>;
     };
-    isOfType(input: unknown): input is Outputs;
 }
 
 type Prettify<T> = T extends unknown ? {
@@ -345,11 +356,11 @@ type UnionToIntersection<U> = (U extends U ? (x: U) => void : never) extends ((x
 declare class SchemaIntersection<Children extends Array<SchemaItem>, Outputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>, Inputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>> extends SchemaItem<Outputs, Inputs> {
     private readonly schemas;
     constructor(...schemas: Children);
+    isOfType(input: unknown): input is Outputs;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
         errors?: Array<ValidationError>;
     };
-    isOfType(input: unknown): input is Outputs;
 }
 
 declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output, Input | null | undefined> {
@@ -358,12 +369,12 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
     private readonly strict;
     constructor(child: Child, defaultVal: Output, strict?: boolean);
     unwrap(): Child;
+    isOfType(input: unknown): input is Output;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
         path: string | undefined;
     }>;
-    isOfType(input: unknown): input is Output;
 }
 
 declare class SchemaFile extends SchemaItem<File> {
@@ -373,17 +384,17 @@ declare class SchemaFile extends SchemaItem<File> {
     isOfType(input: unknown): input is File;
 }
 
-type TupleToOutputs<Tuple extends Array<SchemaItem>, Result extends any[] = []> = number extends Tuple["length"] ? Array<SchemaInfer<Tuple[number]>> : Tuple[Result["length"]] extends undefined ? Result : TupleToOutputs<Tuple, [...Result, SchemaInfer<Tuple[Result["length"]]>]>;
-type TupleToInputs<Tuple extends Array<SchemaItem>, Result extends any[] = []> = number extends Tuple["length"] ? Array<SchemaInputInfer<Tuple[number]>> : Tuple[Result["length"]] extends undefined ? Result : TupleToInputs<Tuple, [...Result, SchemaInputInfer<Tuple[Result["length"]]>]>;
+type TupleToOutputs<Tuple extends Array<SchemaItem>, Result extends Array<any> = []> = number extends Tuple['length'] ? Array<SchemaInfer<Tuple[number]>> : Tuple[Result['length']] extends undefined ? Result : TupleToOutputs<Tuple, [...Result, SchemaInfer<Tuple[Result['length']]>]>;
+type TupleToInputs<Tuple extends Array<SchemaItem>, Result extends Array<any> = []> = number extends Tuple['length'] ? Array<SchemaInputInfer<Tuple[number]>> : Tuple[Result['length']] extends undefined ? Result : TupleToInputs<Tuple, [...Result, SchemaInputInfer<Tuple[Result['length']]>]>;
 declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToOutputs<Children>, Inputs = TupleToInputs<Children>> extends SchemaItem<Outputs, Inputs> {
     private readonly children;
     constructor(...children: Children);
+    isOfType(input: unknown): input is Outputs;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
         path: string | undefined;
     }>;
-    isOfType(input: unknown): input is Outputs;
 }
 
 declare class SchemaUndefined extends SchemaItem<undefined> {
@@ -403,7 +414,10 @@ declare class SchemaNever extends SchemaItem<never> {
 }
 
 declare function isNull(value: unknown): value is undefined | null;
-declare function parseQuery<T extends SchemaItem>(model: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+declare function parseQuery<T extends SchemaItem>(schema: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+/**
+ * (Note: be carefull : missing key/value associated to schema "s.boolean().nullable" or "s.boolean()" will be transform into false)
+ */
 declare function parseFormData<T extends SchemaItem>(schema: T, data: FormData, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 
@@ -412,30 +426,10 @@ declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement
  */
 declare function parsable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
 type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
-declare const Types: {
-    readonly Any: typeof SchemaAny;
-    readonly Array: typeof SchemaArray;
-    readonly Tuple: typeof SchemaTuple;
-    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;
-    readonly Intersection: typeof SchemaIntersection;
-    readonly Default: typeof SchemaDefault;
-    readonly Undefined: typeof SchemaUndefined;
-    readonly Void: typeof SchemaVoid;
-    readonly Null: typeof SchemaNull;
-    readonly Nullish: typeof SchemaNullish;
-};
 declare class Schema<T extends Record<string, SchemaItem> = Record<string, SchemaItem>> extends SchemaObject<T> {
     private static readonly registeredModules;
     static register(module: SchemaItemStatic): void;
-    static getModule(name: string): SchemaItemStatic | undefined;
+    static getModule(name: string): SchemaItemStatic;
     static any(): SchemaAny;
     static array<Type extends SchemaItem>(...inputs: ConstructorParameters<typeof SchemaArray<Type>>): SchemaArray<Type>;
     static boolean(...inputs: ConstructorParameters<typeof SchemaBoolean>): SchemaBoolean;
@@ -446,7 +440,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     * @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 literal<Type extends Array<Literal>>(...inputs: ConstructorParameters<typeof SchemaLiteral<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>;
@@ -457,14 +451,15 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     static string(...inputs: ConstructorParameters<typeof SchemaString>): SchemaString;
     static file(...inputs: ConstructorParameters<typeof SchemaFile>): SchemaFile;
     static union<Type extends Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaUnion<Type>>): SchemaUnion<Type>;
-    static intersection<Type extends SchemaItem[]>(...inputs: ConstructorParameters<typeof SchemaIntersection<Type>>): SchemaIntersection<Type>;
-    static tuple<Items extends SchemaItem[]>(...inputs: ConstructorParameters<typeof SchemaTuple<Items>>): SchemaTuple<Items>;
+    static intersection<Type extends Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaIntersection<Type>>): SchemaIntersection<Type>;
+    static tuple<Items extends Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaTuple<Items>>): SchemaTuple<Items>;
     static undefined(...inputs: ConstructorParameters<typeof SchemaUndefined>): SchemaUndefined;
     static null(...inputs: ConstructorParameters<typeof SchemaNull>): SchemaNull;
     static nullish(...inputs: ConstructorParameters<typeof SchemaNullish>): SchemaNullish;
     static void(...inputs: ConstructorParameters<typeof SchemaVoid>): SchemaVoid;
     static never(...inputs: ConstructorParameters<typeof SchemaNever>): SchemaNever;
     static fromJSON(json: SchemaJSON): SchemaItem;
+    static deepParseSchemaJSON(item: unknown): unknown;
     static isSchemaJSON(data: unknown): data is SchemaJSON;
     /**
      * @deprecated use helper `parseQuery`
@@ -485,4 +480,4 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
 }
 declare const s: typeof Schema;
 
-export { type Infer, type InputInfer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaDefault, SchemaEnum, SchemaFile, type SchemaInfer, type SchemaInputInfer, SchemaIntersection, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNever, SchemaNull, SchemaNullable, SchemaNullish, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUndefined, SchemaUnion, SchemaVoid, Types, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parsable, parseForm, parseFormData, parseQuery, s };
+export { type Infer, type InputInfer, type Literal, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaDefault, SchemaEnum, SchemaFile, type SchemaInfer, type SchemaInputInfer, SchemaIntersection, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNever, SchemaNull, SchemaNullable, SchemaNullish, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUndefined, SchemaUnion, SchemaVoid, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parsable, parseForm, parseFormData, parseQuery, s };