@dzeio/schema 0.6.0 → 0.8.0

package/dist/Schema.d.mts

@@ -3,6 +3,7 @@ import { StandardSchemaV1 } from '@standard-schema/spec';
 declare abstract class SchemaItem<Output = any, Input = Output> implements StandardSchemaV1<Input, Output> {
     readonly _output: Output;
     readonly _input: Input;
+    static id: string;
     '~standard': StandardSchemaV1.Props<Input, Output>;
     /**
      * Function calls saved for serialization
@@ -67,6 +68,7 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     unwrap?(): SchemaItem;
     parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
     toJSON(): SchemaJSON;
+    private deepSerializeItem;
     addValidation(fn: ((input: Output) => boolean) | {
         fn: (input: Output) => boolean;
         error?: string;
@@ -128,7 +130,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,12 +161,16 @@ 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 {
+    static id: string;
     isOfType(_input: unknown): _input is any;
 }
 
 type DateFormat = 'default' | 'iso8601' | 'yy-mm-dd' | 'jj/mm/yy';
 declare class SchemaDate extends SchemaItem<Date> {
+    static id: string;
     parseString(format?: DateFormat): this;
     isOfType(input: unknown): input is Date;
 }
@@ -172,6 +178,7 @@ declare class SchemaDate extends SchemaItem<Date> {
 declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Values extends SchemaItem> extends SchemaItem<Record<SchemaInfer<Keys>, SchemaInfer<Values>>> {
     private readonly keys;
     private readonly values;
+    static id: string;
     constructor(keys: Keys, values: Values);
     isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
@@ -182,11 +189,13 @@ declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Va
 
 declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Array<Output>, Array<Input>> {
     readonly values: Child;
+    static id: string;
     constructor(values: 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
@@ -202,6 +211,7 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
 }
 
 declare class SchemaBoolean extends SchemaItem<boolean> {
+    static id: string;
     /**
      * @param [trueValue='true'] the truhty value (default to `'true'`)
      * @param [falseValue='false'] the falthy value (default to `'false'`)
@@ -216,21 +226,26 @@ interface EnumLike {
 }
 declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
     private readonly templateEnum;
+    static id: string;
     private readonly 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 SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
+    static id: string;
+    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;
+    static id: string;
     constructor(child: Child);
     falsyAsNull(): this;
+    emptyAsNull(): this;
+    emptyFileAsNull(): this;
     unwrap(): Child;
     isOfType(input: unknown): input is Output | undefined;
     protected getSubInputs(input: unknown): Array<{
@@ -245,6 +260,7 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
+    static id: string;
     /**
      * validate that the number is less or equal than {@link value}
      * @param value the maxumum value (inclusive)
@@ -283,7 +299,7 @@ type ModelInfer<M extends Record<string, SchemaItem>> = {
 };
 declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends SchemaItem<ModelInfer<T>> {
     readonly model: T;
-    id: string;
+    static id: string;
     constructor(model: T);
     isOfType(input: unknown): input is ModelInfer<T>;
     protected getSubInputs(input: unknown): Array<{
@@ -294,6 +310,7 @@ declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends S
 }
 
 declare class SchemaString extends SchemaItem<string> {
+    static id: string;
     /**
      * force the input text to be a minimum of `value` size
      * @param value the minimum length of the text
@@ -323,12 +340,18 @@ 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;
 }
 
 declare class SchemaUnion<Children extends Array<SchemaItem>, Outputs = SchemaInfer<Children[number]>, Inputs = SchemaInputInfer<Children[number]>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly schemas;
     constructor(...schemas: Children);
     isOfType(input: unknown): input is Outputs;
@@ -343,6 +366,7 @@ type Prettify<T> = T extends unknown ? {
 } : never;
 type UnionToIntersection<U> = (U extends U ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
 declare class SchemaIntersection<Children extends Array<SchemaItem>, Outputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>, Inputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly schemas;
     constructor(...schemas: Children);
     isOfType(input: unknown): input is Outputs;
@@ -356,6 +380,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
     private readonly child;
     private readonly defaultVal;
     private readonly strict;
+    static id: string;
     constructor(child: Child, defaultVal: Output, strict?: boolean);
     unwrap(): Child;
     isOfType(input: unknown): input is Output;
@@ -367,6 +392,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
 }
 
 declare class SchemaFile extends SchemaItem<File> {
+    static id: string;
     constructor();
     extension(ext: string, error?: string): this;
     maxSize(size: number, error?: string): this;
@@ -376,6 +402,7 @@ declare class SchemaFile extends SchemaItem<File> {
 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> {
+    static id: string;
     private readonly children;
     constructor(...children: Children);
     isOfType(input: unknown): input is Outputs;
@@ -387,18 +414,23 @@ declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToO
 }
 
 declare class SchemaUndefined extends SchemaItem<undefined> {
+    static id: string;
     isOfType(input: unknown): input is undefined;
 }
 declare class SchemaNull extends SchemaItem<null> {
+    static id: string;
     isOfType(input: unknown): input is null;
 }
 declare class SchemaVoid extends SchemaItem<void> {
+    static id: string;
     isOfType(input: unknown): input is void;
 }
 declare class SchemaNullish extends SchemaItem<null | undefined> {
+    static id: string;
     isOfType(input: unknown): input is null | undefined;
 }
 declare class SchemaNever extends SchemaItem<never> {
+    static id: string;
     isOfType(_input: unknown): _input is never;
 }
 
@@ -414,31 +446,13 @@ declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement
  * Decorator for modifier functions on SchemaItems to save them in the "savedCalls" property for the serialization
  */
 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;
+type SchemaItemStatic = (new (...args: Array<any>) => SchemaItem) & {
+    id: string;
 };
 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;
@@ -449,7 +463,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>;
@@ -468,6 +482,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     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`
@@ -488,4 +503,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

@@ -3,6 +3,7 @@ import { StandardSchemaV1 } from '@standard-schema/spec';
 declare abstract class SchemaItem<Output = any, Input = Output> implements StandardSchemaV1<Input, Output> {
     readonly _output: Output;
     readonly _input: Input;
+    static id: string;
     '~standard': StandardSchemaV1.Props<Input, Output>;
     /**
      * Function calls saved for serialization
@@ -67,6 +68,7 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     unwrap?(): SchemaItem;
     parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
     toJSON(): SchemaJSON;
+    private deepSerializeItem;
     addValidation(fn: ((input: Output) => boolean) | {
         fn: (input: Output) => boolean;
         error?: string;
@@ -128,7 +130,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,12 +161,16 @@ 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 {
+    static id: string;
     isOfType(_input: unknown): _input is any;
 }
 
 type DateFormat = 'default' | 'iso8601' | 'yy-mm-dd' | 'jj/mm/yy';
 declare class SchemaDate extends SchemaItem<Date> {
+    static id: string;
     parseString(format?: DateFormat): this;
     isOfType(input: unknown): input is Date;
 }
@@ -172,6 +178,7 @@ declare class SchemaDate extends SchemaItem<Date> {
 declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Values extends SchemaItem> extends SchemaItem<Record<SchemaInfer<Keys>, SchemaInfer<Values>>> {
     private readonly keys;
     private readonly values;
+    static id: string;
     constructor(keys: Keys, values: Values);
     isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
@@ -182,11 +189,13 @@ declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Va
 
 declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Array<Output>, Array<Input>> {
     readonly values: Child;
+    static id: string;
     constructor(values: 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
@@ -202,6 +211,7 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
 }
 
 declare class SchemaBoolean extends SchemaItem<boolean> {
+    static id: string;
     /**
      * @param [trueValue='true'] the truhty value (default to `'true'`)
      * @param [falseValue='false'] the falthy value (default to `'false'`)
@@ -216,21 +226,26 @@ interface EnumLike {
 }
 declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
     private readonly templateEnum;
+    static id: string;
     private readonly 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 SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
+    static id: string;
+    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;
+    static id: string;
     constructor(child: Child);
     falsyAsNull(): this;
+    emptyAsNull(): this;
+    emptyFileAsNull(): this;
     unwrap(): Child;
     isOfType(input: unknown): input is Output | undefined;
     protected getSubInputs(input: unknown): Array<{
@@ -245,6 +260,7 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
+    static id: string;
     /**
      * validate that the number is less or equal than {@link value}
      * @param value the maxumum value (inclusive)
@@ -283,7 +299,7 @@ type ModelInfer<M extends Record<string, SchemaItem>> = {
 };
 declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends SchemaItem<ModelInfer<T>> {
     readonly model: T;
-    id: string;
+    static id: string;
     constructor(model: T);
     isOfType(input: unknown): input is ModelInfer<T>;
     protected getSubInputs(input: unknown): Array<{
@@ -294,6 +310,7 @@ declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends S
 }
 
 declare class SchemaString extends SchemaItem<string> {
+    static id: string;
     /**
      * force the input text to be a minimum of `value` size
      * @param value the minimum length of the text
@@ -323,12 +340,18 @@ 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;
 }
 
 declare class SchemaUnion<Children extends Array<SchemaItem>, Outputs = SchemaInfer<Children[number]>, Inputs = SchemaInputInfer<Children[number]>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly schemas;
     constructor(...schemas: Children);
     isOfType(input: unknown): input is Outputs;
@@ -343,6 +366,7 @@ type Prettify<T> = T extends unknown ? {
 } : never;
 type UnionToIntersection<U> = (U extends U ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
 declare class SchemaIntersection<Children extends Array<SchemaItem>, Outputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>, Inputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>> extends SchemaItem<Outputs, Inputs> {
+    static id: string;
     private readonly schemas;
     constructor(...schemas: Children);
     isOfType(input: unknown): input is Outputs;
@@ -356,6 +380,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
     private readonly child;
     private readonly defaultVal;
     private readonly strict;
+    static id: string;
     constructor(child: Child, defaultVal: Output, strict?: boolean);
     unwrap(): Child;
     isOfType(input: unknown): input is Output;
@@ -367,6 +392,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
 }
 
 declare class SchemaFile extends SchemaItem<File> {
+    static id: string;
     constructor();
     extension(ext: string, error?: string): this;
     maxSize(size: number, error?: string): this;
@@ -376,6 +402,7 @@ declare class SchemaFile extends SchemaItem<File> {
 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> {
+    static id: string;
     private readonly children;
     constructor(...children: Children);
     isOfType(input: unknown): input is Outputs;
@@ -387,18 +414,23 @@ declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToO
 }
 
 declare class SchemaUndefined extends SchemaItem<undefined> {
+    static id: string;
     isOfType(input: unknown): input is undefined;
 }
 declare class SchemaNull extends SchemaItem<null> {
+    static id: string;
     isOfType(input: unknown): input is null;
 }
 declare class SchemaVoid extends SchemaItem<void> {
+    static id: string;
     isOfType(input: unknown): input is void;
 }
 declare class SchemaNullish extends SchemaItem<null | undefined> {
+    static id: string;
     isOfType(input: unknown): input is null | undefined;
 }
 declare class SchemaNever extends SchemaItem<never> {
+    static id: string;
     isOfType(_input: unknown): _input is never;
 }
 
@@ -414,31 +446,13 @@ declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement
  * Decorator for modifier functions on SchemaItems to save them in the "savedCalls" property for the serialization
  */
 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;
+type SchemaItemStatic = (new (...args: Array<any>) => SchemaItem) & {
+    id: string;
 };
 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;
@@ -449,7 +463,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>;
@@ -468,6 +482,7 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
     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`
@@ -488,4 +503,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.js

@@ -49,7 +49,6 @@ __export(Schema_exports, {
   SchemaUndefined: () => SchemaUndefined,
   SchemaUnion: () => SchemaUnion,
   SchemaVoid: () => SchemaVoid,
-  Types: () => Types,
   default: () => Schema,
   isNull: () => isNull,
   parsable: () => parsable,
@@ -180,7 +179,7 @@ var _SchemaItem = class _SchemaItem {
     if (!this.isOfType(input)) {
       return {
         valid: false,
-        errors: [{ message: "invalid type" }]
+        errors: [{ message: this.invalidError }]
       };
     }
     const validationErrors = [];
@@ -212,14 +211,24 @@ var _SchemaItem = class _SchemaItem {
   toJSON() {
     var _a;
     const res = {
-      i: this.constructor.name,
+      _i: this.constructor.id,
       a: this.attributes.length > 0 ? this.attributes : void 0,
-      c: (_a = this.items) == null ? void 0 : _a.map((it) => it instanceof _SchemaItem ? it.toJSON() : it),
+      c: (_a = this.items) == null ? void 0 : _a.map((it) => this.deepSerializeItem(it)),
       f: this.savedCalls.map((it) => it.args ? { n: it.name, a: Array.from(it.args) } : { n: it.name })
     };
     (0, import_object_util.objectClean)(res, { deep: false });
     return res;
   }
+  deepSerializeItem(item) {
+    if (item instanceof _SchemaItem) {
+      return item.toJSON();
+    } else if (Array.isArray(item)) {
+      return item.map((it) => this.deepSerializeItem(it));
+    } else if ((0, import_object_util.isObject)(item)) {
+      return (0, import_object_util.objectRemap)(item, (value, key) => ({ value: this.deepSerializeItem(value), key }));
+    }
+    return item;
+  }
   addValidation(fn, error) {
     this.validations.push(typeof fn === "function" ? { fn, error } : fn);
     return this;
@@ -283,6 +292,10 @@ var SchemaArray = class extends SchemaItem {
     this.postProcess.push((input) => input.filter((it, idx) => input.indexOf(it) === idx));
     return this;
   }
+  clean() {
+    this.postProcess.push((input) => input.filter((it) => !isNull(it)));
+    return this;
+  }
   split(separator = ",") {
     this.addPreProcess((it) => typeof it === "string" ? it.split(separator) : it);
     return this;
@@ -297,9 +310,13 @@ var SchemaArray = class extends SchemaItem {
     return Array.isArray(input) ? input.map((entry, index) => ({ item: this.values, value: entry, path: index.toString() })) : [];
   }
 };
+SchemaArray.id = "array";
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "unique", 1);
+__decorateClass([
+  parsable()
+], SchemaArray.prototype, "clean", 1);
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "split", 1);
@@ -325,6 +342,7 @@ var SchemaBoolean = class extends SchemaItem {
     return typeof input === "boolean";
   }
 };
+SchemaBoolean.id = "boolean";
 __decorateClass([
   parsable()
 ], SchemaBoolean.prototype, "parseString", 1);
@@ -339,6 +357,14 @@ var SchemaNullable = class extends SchemaItem {
     this.addPreProcess((it) => !it ? void 0 : it);
     return this;
   }
+  emptyAsNull() {
+    this.addPreProcess((it) => it === "" ? void 0 : it);
+    return this;
+  }
+  emptyFileAsNull() {
+    this.addPreProcess((it) => it instanceof File && it.size === 0 ? void 0 : it);
+    return this;
+  }
   unwrap() {
     return this.child;
   }
@@ -355,9 +381,16 @@ var SchemaNullable = class extends SchemaItem {
     return super.parseSubItems(input, options);
   }
 };
+SchemaNullable.id = "nullable";
 __decorateClass([
   parsable()
 ], SchemaNullable.prototype, "falsyAsNull", 1);
+__decorateClass([
+  parsable()
+], SchemaNullable.prototype, "emptyAsNull", 1);
+__decorateClass([
+  parsable()
+], SchemaNullable.prototype, "emptyFileAsNull", 1);
 
 // src/items/object.ts
 var import_object_util2 = require("@dzeio/object-util");
@@ -365,7 +398,6 @@ var SchemaObject = class extends SchemaItem {
   constructor(model) {
     super([model]);
     this.model = model;
-    this.id = "object";
   }
   isOfType(input) {
     return (0, import_object_util2.isObject)(input) && !(0, import_object_util2.objectFind)(this.model, (item, key) => !item.isOfType(input[key]));
@@ -374,6 +406,7 @@ var SchemaObject = class extends SchemaItem {
     return (0, import_object_util2.isObject)(input) ? (0, import_object_util2.objectMap)(this.model, (schema, key) => ({ item: schema, value: input[key], path: key.toString() })) : [];
   }
 };
+SchemaObject.id = "object";
 
 // src/helpers.ts
 function isNull(value) {
@@ -384,7 +417,8 @@ function parseQuery(schema, query, opts) {
   for (const [key, value] of query) {
     const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
     const schemaItem = getSchemaItemAtPath(schema, keys);
-    const finalValue = schemaItem instanceof SchemaArray ? query.getAll(key) : value;
+    const allValues = query.getAll(key);
+    const finalValue = schemaItem && schemaItem.parse(allValues).valid ? allValues : value;
     (0, import_object_util3.objectSet)(record, keys, finalValue);
   }
   return schema.parse(record, opts);
@@ -394,7 +428,8 @@ function parseFormData(schema, data, opts) {
   for (const [key, value] of data) {
     const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
     const schemaItem = getSchemaItemAtPath(schema, keys);
-    const finalValue = schemaItem instanceof SchemaArray ? data.getAll(key) : value;
+    const allValues = data.getAll(key);
+    const finalValue = schemaItem && schemaItem.parse(allValues).valid ? allValues : value;
     (0, import_object_util3.objectSet)(record, keys, finalValue);
   }
   const handleBoolean = (value, keys) => {
@@ -456,6 +491,7 @@ var SchemaAny = class extends SchemaItem {
     return true;
   }
 };
+SchemaAny.id = "any";
 
 // src/items/date.ts
 var SchemaDate = class extends SchemaItem {
@@ -499,6 +535,7 @@ var SchemaDate = class extends SchemaItem {
     return input instanceof Date;
   }
 };
+SchemaDate.id = "date";
 __decorateClass([
   parsable()
 ], SchemaDate.prototype, "parseString", 1);
@@ -537,6 +574,7 @@ var SchemaRecord = class extends SchemaItem {
     return result;
   }
 };
+SchemaRecord.id = "record";
 
 // src/items/enum.ts
 var SchemaEnum = class extends SchemaItem {
@@ -557,18 +595,20 @@ var SchemaEnum = class extends SchemaItem {
     return typeof input === this.type;
   }
 };
+SchemaEnum.id = "enum";
 
 // src/items/literal.ts
 var SchemaLiteral = class extends SchemaItem {
-  constructor(value) {
-    super([value]);
-    this.value = value;
-    this.validations.push({ fn: (it) => it === this.value });
+  constructor(...values) {
+    super(values);
+    this.values = values;
+    this.validations.push({ fn: (it) => this.values.includes(it) });
   }
   isOfType(input) {
-    return typeof input === typeof this.value;
+    return this.values.some((it) => typeof input === typeof it);
   }
 };
+SchemaLiteral.id = "literal";
 
 // src/items/number.ts
 var SchemaNumber = class extends SchemaItem {
@@ -622,6 +662,7 @@ var SchemaNumber = class extends SchemaItem {
     return this.lte(...params);
   }
 };
+SchemaNumber.id = "number";
 __decorateClass([
   parsable()
 ], SchemaNumber.prototype, "lte", 1);
@@ -681,6 +722,15 @@ var SchemaString = class extends SchemaItem {
     });
     return this;
   }
+  email(message) {
+    this.addValidation({
+      fn(input) {
+        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input);
+      },
+      error: message
+    });
+    return this;
+  }
   minLength(value, message) {
     return this.min(value, message);
   }
@@ -691,6 +741,7 @@ var SchemaString = class extends SchemaItem {
     return typeof input === "string";
   }
 };
+SchemaString.id = "string";
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "min", 1);
@@ -706,6 +757,9 @@ __decorateClass([
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "regex", 1);
+__decorateClass([
+  parsable()
+], SchemaString.prototype, "email", 1);
 
 // src/items/union.ts
 var SchemaUnion = class extends SchemaItem {
@@ -729,6 +783,7 @@ var SchemaUnion = class extends SchemaItem {
     return result;
   }
 };
+SchemaUnion.id = "union";
 
 // src/items/intersection.ts
 var import_object_util5 = require("@dzeio/object-util");
@@ -757,6 +812,7 @@ var SchemaIntersection = class extends SchemaItem {
     return result;
   }
 };
+SchemaIntersection.id = "intersection";
 
 // src/items/default.ts
 var SchemaDefault = class extends SchemaItem {
@@ -776,6 +832,7 @@ var SchemaDefault = class extends SchemaItem {
     return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
   }
 };
+SchemaDefault.id = "default";
 
 // src/items/file.ts
 var SchemaFile = class extends SchemaItem {
@@ -795,6 +852,7 @@ var SchemaFile = class extends SchemaItem {
     return input instanceof File;
   }
 };
+SchemaFile.id = "file";
 __decorateClass([
   parsable()
 ], SchemaFile.prototype, "extension", 1);
@@ -823,6 +881,7 @@ var SchemaTuple = class extends SchemaItem {
     return Array.isArray(input) ? this.children.map((entry, index) => ({ value: input[index], item: entry, path: index.toString() })) : [];
   }
 };
+SchemaTuple.id = "tuple";
 
 // src/items/nullish.ts
 var SchemaUndefined = class extends SchemaItem {
@@ -830,28 +889,34 @@ var SchemaUndefined = class extends SchemaItem {
     return typeof input === "undefined";
   }
 };
+SchemaUndefined.id = "undefined";
 var SchemaNull = class extends SchemaItem {
   isOfType(input) {
     return input === null;
   }
 };
+SchemaNull.id = "null";
 var SchemaVoid = class extends SchemaItem {
   isOfType(input) {
     return typeof input === "undefined";
   }
 };
+SchemaVoid.id = "void";
 var SchemaNullish = class extends SchemaItem {
   isOfType(input) {
     return isNull(input);
   }
 };
+SchemaNullish.id = "nullish";
 var SchemaNever = class extends SchemaItem {
   isOfType(_input) {
     return false;
   }
 };
+SchemaNever.id = "never";
 
 // src/Schema.ts
+var import_object_util6 = require("@dzeio/object-util");
 function parsable() {
   return (target, propertyKey, descriptor) => {
     if (!(propertyKey in target)) {
@@ -866,32 +931,16 @@ function parsable() {
     return descriptor;
   };
 }
-var Types = {
-  Any: SchemaAny,
-  Array: SchemaArray,
-  Tuple: SchemaTuple,
-  Boolean: SchemaBoolean,
-  Date: SchemaDate,
-  Enum: SchemaEnum,
-  Literal: SchemaLiteral,
-  Nullable: SchemaNullable,
-  Object: SchemaObject,
-  Record: SchemaRecord,
-  String: SchemaString,
-  Union: SchemaUnion,
-  Intersection: SchemaIntersection,
-  Default: SchemaDefault,
-  Undefined: SchemaUndefined,
-  Void: SchemaVoid,
-  Null: SchemaNull,
-  Nullish: SchemaNullish
-};
 var _Schema = class _Schema extends SchemaObject {
   static register(module2) {
     this.registeredModules.push(module2);
   }
   static getModule(name) {
-    return this.registeredModules.find((it) => it.name === name);
+    const module2 = this.registeredModules.find((it) => it.id === name);
+    if (!module2) {
+      console.log("Couldn't find module", name);
+    }
+    return module2 != null ? module2 : SchemaAny;
   }
   static any() {
     return new SchemaAny();
@@ -913,8 +962,8 @@ var _Schema = class _Schema extends SchemaObject {
   * @param input the literal value (note: append `as const` else the typing won't work correctly)
   * @returns
   */
-  static literal(input) {
-    return new SchemaLiteral(input);
+  static literal(...inputs) {
+    return new SchemaLiteral(...inputs);
   }
   static nullable(...inputs) {
     return new SchemaNullable(...inputs);
@@ -963,25 +1012,35 @@ var _Schema = class _Schema extends SchemaObject {
   }
   static fromJSON(json) {
     var _a, _b, _c, _d, _e, _f;
-    const fn = this.getModule(json.i);
+    const fn = this.getModule(json._i);
     if (!fn) {
-      throw new Error(`Schema cannot parse ${json.i}`);
+      throw new Error(`Schema cannot parse ${json._i}`);
     }
-    const item = new fn(...(_b = (_a = json.c) == null ? void 0 : _a.map((it) => this.isSchemaJSON(it) ? _Schema.fromJSON(it) : it)) != null ? _b : []);
+    const item = new fn(...(_b = (_a = json.c) == null ? void 0 : _a.map((it) => this.deepParseSchemaJSON(it))) != null ? _b : []);
     for (const validation of (_c = json.f) != null ? _c : []) {
       if (!(validation.n in item)) {
         throw new Error("validation not available in Schema Item");
       }
-      item[validation.n](...(_e = (_d = validation.a) == null ? void 0 : _d.map((it) => _Schema.isSchemaJSON(it) ? _Schema.fromJSON(it) : it)) != null ? _e : []);
+      item[validation.n](...(_e = (_d = validation.a) == null ? void 0 : _d.map((it) => this.deepParseSchemaJSON(it))) != null ? _e : []);
     }
     item.attrs(...(_f = json.a) != null ? _f : []);
     return item;
   }
+  static deepParseSchemaJSON(item) {
+    if (this.isSchemaJSON(item)) {
+      return _Schema.fromJSON(item);
+    } else if (Array.isArray(item)) {
+      return item.map((it) => this.deepParseSchemaJSON(it));
+    } else if ((0, import_object_util6.isObject)(item)) {
+      return (0, import_object_util6.objectRemap)(item, (value, key) => ({ value: this.deepParseSchemaJSON(value), key }));
+    }
+    return item;
+  }
   static isSchemaJSON(data) {
     if (typeof data !== "object" || data === null) {
       return false;
     }
-    if (!("i" in data)) {
+    if (!("_i" in data)) {
       return false;
     }
     return true;
@@ -1028,7 +1087,10 @@ _Schema.registeredModules = [
   SchemaUndefined,
   SchemaVoid,
   SchemaNull,
-  SchemaNullish
+  SchemaNullish,
+  SchemaFile,
+  SchemaAny,
+  SchemaNumber
 ];
 var Schema = _Schema;
 var s = Schema;
@@ -1055,7 +1117,6 @@ var s = Schema;
   SchemaUndefined,
   SchemaUnion,
   SchemaVoid,
-  Types,
   isNull,
   parsable,
   parseForm,

package/dist/Schema.mjs

@@ -13,7 +13,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 import { objectClone, objectGet, objectLoop, objectSet as objectSet2 } from "@dzeio/object-util";
 
 // src/SchemaItem.ts
-import { isObject, objectClean, objectSet } from "@dzeio/object-util";
+import { isObject, objectClean, objectRemap, objectSet } from "@dzeio/object-util";
 var _SchemaItem = class _SchemaItem {
   constructor(items) {
     // standard Schema V1 spec
@@ -129,7 +129,7 @@ var _SchemaItem = class _SchemaItem {
     if (!this.isOfType(input)) {
       return {
         valid: false,
-        errors: [{ message: "invalid type" }]
+        errors: [{ message: this.invalidError }]
       };
     }
     const validationErrors = [];
@@ -161,14 +161,24 @@ var _SchemaItem = class _SchemaItem {
   toJSON() {
     var _a;
     const res = {
-      i: this.constructor.name,
+      _i: this.constructor.id,
       a: this.attributes.length > 0 ? this.attributes : void 0,
-      c: (_a = this.items) == null ? void 0 : _a.map((it) => it instanceof _SchemaItem ? it.toJSON() : it),
+      c: (_a = this.items) == null ? void 0 : _a.map((it) => this.deepSerializeItem(it)),
       f: this.savedCalls.map((it) => it.args ? { n: it.name, a: Array.from(it.args) } : { n: it.name })
     };
     objectClean(res, { deep: false });
     return res;
   }
+  deepSerializeItem(item) {
+    if (item instanceof _SchemaItem) {
+      return item.toJSON();
+    } else if (Array.isArray(item)) {
+      return item.map((it) => this.deepSerializeItem(it));
+    } else if (isObject(item)) {
+      return objectRemap(item, (value, key) => ({ value: this.deepSerializeItem(value), key }));
+    }
+    return item;
+  }
   addValidation(fn, error) {
     this.validations.push(typeof fn === "function" ? { fn, error } : fn);
     return this;
@@ -232,6 +242,10 @@ var SchemaArray = class extends SchemaItem {
     this.postProcess.push((input) => input.filter((it, idx) => input.indexOf(it) === idx));
     return this;
   }
+  clean() {
+    this.postProcess.push((input) => input.filter((it) => !isNull(it)));
+    return this;
+  }
   split(separator = ",") {
     this.addPreProcess((it) => typeof it === "string" ? it.split(separator) : it);
     return this;
@@ -246,9 +260,13 @@ var SchemaArray = class extends SchemaItem {
     return Array.isArray(input) ? input.map((entry, index) => ({ item: this.values, value: entry, path: index.toString() })) : [];
   }
 };
+SchemaArray.id = "array";
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "unique", 1);
+__decorateClass([
+  parsable()
+], SchemaArray.prototype, "clean", 1);
 __decorateClass([
   parsable()
 ], SchemaArray.prototype, "split", 1);
@@ -274,6 +292,7 @@ var SchemaBoolean = class extends SchemaItem {
     return typeof input === "boolean";
   }
 };
+SchemaBoolean.id = "boolean";
 __decorateClass([
   parsable()
 ], SchemaBoolean.prototype, "parseString", 1);
@@ -288,6 +307,14 @@ var SchemaNullable = class extends SchemaItem {
     this.addPreProcess((it) => !it ? void 0 : it);
     return this;
   }
+  emptyAsNull() {
+    this.addPreProcess((it) => it === "" ? void 0 : it);
+    return this;
+  }
+  emptyFileAsNull() {
+    this.addPreProcess((it) => it instanceof File && it.size === 0 ? void 0 : it);
+    return this;
+  }
   unwrap() {
     return this.child;
   }
@@ -304,9 +331,16 @@ var SchemaNullable = class extends SchemaItem {
     return super.parseSubItems(input, options);
   }
 };
+SchemaNullable.id = "nullable";
 __decorateClass([
   parsable()
 ], SchemaNullable.prototype, "falsyAsNull", 1);
+__decorateClass([
+  parsable()
+], SchemaNullable.prototype, "emptyAsNull", 1);
+__decorateClass([
+  parsable()
+], SchemaNullable.prototype, "emptyFileAsNull", 1);
 
 // src/items/object.ts
 import { isObject as isObject2, objectFind, objectMap } from "@dzeio/object-util";
@@ -314,7 +348,6 @@ var SchemaObject = class extends SchemaItem {
   constructor(model) {
     super([model]);
     this.model = model;
-    this.id = "object";
   }
   isOfType(input) {
     return isObject2(input) && !objectFind(this.model, (item, key) => !item.isOfType(input[key]));
@@ -323,6 +356,7 @@ var SchemaObject = class extends SchemaItem {
     return isObject2(input) ? objectMap(this.model, (schema, key) => ({ item: schema, value: input[key], path: key.toString() })) : [];
   }
 };
+SchemaObject.id = "object";
 
 // src/helpers.ts
 function isNull(value) {
@@ -333,7 +367,8 @@ function parseQuery(schema, query, opts) {
   for (const [key, value] of query) {
     const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
     const schemaItem = getSchemaItemAtPath(schema, keys);
-    const finalValue = schemaItem instanceof SchemaArray ? query.getAll(key) : value;
+    const allValues = query.getAll(key);
+    const finalValue = schemaItem && schemaItem.parse(allValues).valid ? allValues : value;
     objectSet2(record, keys, finalValue);
   }
   return schema.parse(record, opts);
@@ -343,7 +378,8 @@ function parseFormData(schema, data, opts) {
   for (const [key, value] of data) {
     const keys = key.split(".").map((it) => /^\d+$/g.test(it) ? Number.parseInt(it, 10) : it);
     const schemaItem = getSchemaItemAtPath(schema, keys);
-    const finalValue = schemaItem instanceof SchemaArray ? data.getAll(key) : value;
+    const allValues = data.getAll(key);
+    const finalValue = schemaItem && schemaItem.parse(allValues).valid ? allValues : value;
     objectSet2(record, keys, finalValue);
   }
   const handleBoolean = (value, keys) => {
@@ -405,6 +441,7 @@ var SchemaAny = class extends SchemaItem {
     return true;
   }
 };
+SchemaAny.id = "any";
 
 // src/items/date.ts
 var SchemaDate = class extends SchemaItem {
@@ -448,6 +485,7 @@ var SchemaDate = class extends SchemaItem {
     return input instanceof Date;
   }
 };
+SchemaDate.id = "date";
 __decorateClass([
   parsable()
 ], SchemaDate.prototype, "parseString", 1);
@@ -486,6 +524,7 @@ var SchemaRecord = class extends SchemaItem {
     return result;
   }
 };
+SchemaRecord.id = "record";
 
 // src/items/enum.ts
 var SchemaEnum = class extends SchemaItem {
@@ -506,18 +545,20 @@ var SchemaEnum = class extends SchemaItem {
     return typeof input === this.type;
   }
 };
+SchemaEnum.id = "enum";
 
 // src/items/literal.ts
 var SchemaLiteral = class extends SchemaItem {
-  constructor(value) {
-    super([value]);
-    this.value = value;
-    this.validations.push({ fn: (it) => it === this.value });
+  constructor(...values) {
+    super(values);
+    this.values = values;
+    this.validations.push({ fn: (it) => this.values.includes(it) });
   }
   isOfType(input) {
-    return typeof input === typeof this.value;
+    return this.values.some((it) => typeof input === typeof it);
   }
 };
+SchemaLiteral.id = "literal";
 
 // src/items/number.ts
 var SchemaNumber = class extends SchemaItem {
@@ -571,6 +612,7 @@ var SchemaNumber = class extends SchemaItem {
     return this.lte(...params);
   }
 };
+SchemaNumber.id = "number";
 __decorateClass([
   parsable()
 ], SchemaNumber.prototype, "lte", 1);
@@ -630,6 +672,15 @@ var SchemaString = class extends SchemaItem {
     });
     return this;
   }
+  email(message) {
+    this.addValidation({
+      fn(input) {
+        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input);
+      },
+      error: message
+    });
+    return this;
+  }
   minLength(value, message) {
     return this.min(value, message);
   }
@@ -640,6 +691,7 @@ var SchemaString = class extends SchemaItem {
     return typeof input === "string";
   }
 };
+SchemaString.id = "string";
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "min", 1);
@@ -655,6 +707,9 @@ __decorateClass([
 __decorateClass([
   parsable()
 ], SchemaString.prototype, "regex", 1);
+__decorateClass([
+  parsable()
+], SchemaString.prototype, "email", 1);
 
 // src/items/union.ts
 var SchemaUnion = class extends SchemaItem {
@@ -678,6 +733,7 @@ var SchemaUnion = class extends SchemaItem {
     return result;
   }
 };
+SchemaUnion.id = "union";
 
 // src/items/intersection.ts
 import { isObject as isObject4 } from "@dzeio/object-util";
@@ -706,6 +762,7 @@ var SchemaIntersection = class extends SchemaItem {
     return result;
   }
 };
+SchemaIntersection.id = "intersection";
 
 // src/items/default.ts
 var SchemaDefault = class extends SchemaItem {
@@ -725,6 +782,7 @@ var SchemaDefault = class extends SchemaItem {
     return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
   }
 };
+SchemaDefault.id = "default";
 
 // src/items/file.ts
 var SchemaFile = class extends SchemaItem {
@@ -744,6 +802,7 @@ var SchemaFile = class extends SchemaItem {
     return input instanceof File;
   }
 };
+SchemaFile.id = "file";
 __decorateClass([
   parsable()
 ], SchemaFile.prototype, "extension", 1);
@@ -772,6 +831,7 @@ var SchemaTuple = class extends SchemaItem {
     return Array.isArray(input) ? this.children.map((entry, index) => ({ value: input[index], item: entry, path: index.toString() })) : [];
   }
 };
+SchemaTuple.id = "tuple";
 
 // src/items/nullish.ts
 var SchemaUndefined = class extends SchemaItem {
@@ -779,28 +839,34 @@ var SchemaUndefined = class extends SchemaItem {
     return typeof input === "undefined";
   }
 };
+SchemaUndefined.id = "undefined";
 var SchemaNull = class extends SchemaItem {
   isOfType(input) {
     return input === null;
   }
 };
+SchemaNull.id = "null";
 var SchemaVoid = class extends SchemaItem {
   isOfType(input) {
     return typeof input === "undefined";
   }
 };
+SchemaVoid.id = "void";
 var SchemaNullish = class extends SchemaItem {
   isOfType(input) {
     return isNull(input);
   }
 };
+SchemaNullish.id = "nullish";
 var SchemaNever = class extends SchemaItem {
   isOfType(_input) {
     return false;
   }
 };
+SchemaNever.id = "never";
 
 // src/Schema.ts
+import { isObject as isObject5, objectRemap as objectRemap2 } from "@dzeio/object-util";
 function parsable() {
   return (target, propertyKey, descriptor) => {
     if (!(propertyKey in target)) {
@@ -815,32 +881,16 @@ function parsable() {
     return descriptor;
   };
 }
-var Types = {
-  Any: SchemaAny,
-  Array: SchemaArray,
-  Tuple: SchemaTuple,
-  Boolean: SchemaBoolean,
-  Date: SchemaDate,
-  Enum: SchemaEnum,
-  Literal: SchemaLiteral,
-  Nullable: SchemaNullable,
-  Object: SchemaObject,
-  Record: SchemaRecord,
-  String: SchemaString,
-  Union: SchemaUnion,
-  Intersection: SchemaIntersection,
-  Default: SchemaDefault,
-  Undefined: SchemaUndefined,
-  Void: SchemaVoid,
-  Null: SchemaNull,
-  Nullish: SchemaNullish
-};
 var _Schema = class _Schema extends SchemaObject {
   static register(module) {
     this.registeredModules.push(module);
   }
   static getModule(name) {
-    return this.registeredModules.find((it) => it.name === name);
+    const module = this.registeredModules.find((it) => it.id === name);
+    if (!module) {
+      console.log("Couldn't find module", name);
+    }
+    return module != null ? module : SchemaAny;
   }
   static any() {
     return new SchemaAny();
@@ -862,8 +912,8 @@ var _Schema = class _Schema extends SchemaObject {
   * @param input the literal value (note: append `as const` else the typing won't work correctly)
   * @returns
   */
-  static literal(input) {
-    return new SchemaLiteral(input);
+  static literal(...inputs) {
+    return new SchemaLiteral(...inputs);
   }
   static nullable(...inputs) {
     return new SchemaNullable(...inputs);
@@ -912,25 +962,35 @@ var _Schema = class _Schema extends SchemaObject {
   }
   static fromJSON(json) {
     var _a, _b, _c, _d, _e, _f;
-    const fn = this.getModule(json.i);
+    const fn = this.getModule(json._i);
     if (!fn) {
-      throw new Error(`Schema cannot parse ${json.i}`);
+      throw new Error(`Schema cannot parse ${json._i}`);
     }
-    const item = new fn(...(_b = (_a = json.c) == null ? void 0 : _a.map((it) => this.isSchemaJSON(it) ? _Schema.fromJSON(it) : it)) != null ? _b : []);
+    const item = new fn(...(_b = (_a = json.c) == null ? void 0 : _a.map((it) => this.deepParseSchemaJSON(it))) != null ? _b : []);
     for (const validation of (_c = json.f) != null ? _c : []) {
       if (!(validation.n in item)) {
         throw new Error("validation not available in Schema Item");
       }
-      item[validation.n](...(_e = (_d = validation.a) == null ? void 0 : _d.map((it) => _Schema.isSchemaJSON(it) ? _Schema.fromJSON(it) : it)) != null ? _e : []);
+      item[validation.n](...(_e = (_d = validation.a) == null ? void 0 : _d.map((it) => this.deepParseSchemaJSON(it))) != null ? _e : []);
     }
     item.attrs(...(_f = json.a) != null ? _f : []);
     return item;
   }
+  static deepParseSchemaJSON(item) {
+    if (this.isSchemaJSON(item)) {
+      return _Schema.fromJSON(item);
+    } else if (Array.isArray(item)) {
+      return item.map((it) => this.deepParseSchemaJSON(it));
+    } else if (isObject5(item)) {
+      return objectRemap2(item, (value, key) => ({ value: this.deepParseSchemaJSON(value), key }));
+    }
+    return item;
+  }
   static isSchemaJSON(data) {
     if (typeof data !== "object" || data === null) {
       return false;
     }
-    if (!("i" in data)) {
+    if (!("_i" in data)) {
       return false;
     }
     return true;
@@ -977,7 +1037,10 @@ _Schema.registeredModules = [
   SchemaUndefined,
   SchemaVoid,
   SchemaNull,
-  SchemaNullish
+  SchemaNullish,
+  SchemaFile,
+  SchemaAny,
+  SchemaNumber
 ];
 var Schema = _Schema;
 var s = Schema;
@@ -1003,7 +1066,6 @@ export {
   SchemaUndefined,
   SchemaUnion,
   SchemaVoid,
-  Types,
   Schema as default,
   isNull,
   parsable,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dzeio/schema",
-	"version": "0.6.0",
+	"version": "0.8.0",
 	"dependencies": {
 		"@dzeio/object-util": "^1.9.2"
 	},