@dzeio/schema 0.5.0 → 0.6.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,14 @@ 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;
+    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 +85,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 {
@@ -173,11 +173,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>> {
@@ -192,13 +192,13 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
     * @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> {
@@ -232,6 +232,7 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
     constructor(child: Child);
     falsyAsNull(): this;
     unwrap(): Child;
+    isOfType(input: unknown): input is Output | undefined;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
@@ -241,7 +242,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 +285,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> {
@@ -331,11 +331,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 +345,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 +358,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 +373,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 +403,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']>;
 
@@ -457,8 +460,8 @@ 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;

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,14 @@ 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;
+    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 +85,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 {
@@ -173,11 +173,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>> {
@@ -192,13 +192,13 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
     * @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> {
@@ -232,6 +232,7 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
     constructor(child: Child);
     falsyAsNull(): this;
     unwrap(): Child;
+    isOfType(input: unknown): input is Output | undefined;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
         value: unknown;
@@ -241,7 +242,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 +285,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> {
@@ -331,11 +331,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 +345,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 +358,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 +373,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 +403,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']>;
 
@@ -457,8 +460,8 @@ 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;

package/dist/Schema.js

@@ -84,14 +84,18 @@ var _SchemaItem = class _SchemaItem {
         };
       }
     };
-    /**
-     * keep public ?
-     */
-    this.validations = [];
     /**
      * Function calls saved for serialization
      */
     this.savedCalls = [];
+    /**
+     * list of attributes for custom works
+     */
+    this.attributes = [];
+    /**
+     * keep public ?
+     */
+    this.validations = [];
     /**
      * Pre process the variable for various reasons
      *
@@ -109,16 +113,23 @@ var _SchemaItem = class _SchemaItem {
      * note: the type of the final post-process MUST be valid
      */
     this.postProcess = [];
-    /**
-     * list of attributes for custom works
-     */
-    this.attributes = [];
     this.invalidError = "the field is invalid";
+    // eslint-disable-next-line @typescript-eslint/member-ordering, @typescript-eslint/unbound-method
     this.default = this.defaultValue;
     if (items && items.length > 0) {
       this.items = Array.isArray(items) ? items : Array.from(items);
     }
   }
+  parseJSON() {
+    this.addPreProcess((input) => {
+      try {
+        return typeof input === "string" ? JSON.parse(input) : input;
+      } catch {
+        return input;
+      }
+    });
+    return this;
+  }
   in(...values) {
     this.addValidation((input) => values.includes(input));
     return this;
@@ -152,37 +163,7 @@ var _SchemaItem = class _SchemaItem {
   array() {
     return new SchemaArray(this);
   }
-  /** Returns the sub values of the input, the schema item to handle them, and the path to it */
-  getSubInputs(_input) {
-    return [];
-  }
-  /** Sets the "part" of the input that this sub schema handles. Overrides the input with the result */
-  updateSubItemInput(path, input, value) {
-    if (path && (0, import_object_util.isObject)(input)) {
-      (0, import_object_util.objectSet)(input, path.split("."), value);
-      return input;
-    } else {
-      return value;
-    }
-  }
-  parseSubItems(input, options) {
-    const result = { errors: [], input };
-    for (const { item, value, path } of this.getSubInputs(result.input)) {
-      const parsed = item.parse(value, options);
-      if (parsed.valid) {
-        result.input = this.updateSubItemInput(path, result.input, parsed.object);
-      } else {
-        for (const error of parsed.errors) {
-          error.field = error.field ? `${path}.${error.field}` : path;
-          result.errors.push(error);
-        }
-        if (options == null ? void 0 : options.fast) {
-          break;
-        }
-      }
-    }
-    return result;
-  }
+  // eslint-disable-next-line complexity
   parse(input, options) {
     var _a, _b;
     for (const preProcess of this.preProcess) {
@@ -252,23 +233,44 @@ var _SchemaItem = class _SchemaItem {
     this.postProcess.push(fn);
     return this;
   }
-  parseJSON() {
-    this.addPreProcess((input) => {
-      try {
-        return typeof input === "string" ? JSON.parse(input) : input;
-      } catch {
-        return input;
+  /** Returns the sub values of the input, the schema item to handle them, and the path to it */
+  getSubInputs(_input) {
+    return [];
+  }
+  /** Sets the "part" of the input that this sub schema handles. Overrides the input with the result */
+  updateSubItemInput(path, input, value) {
+    if (path && (0, import_object_util.isObject)(input)) {
+      (0, import_object_util.objectSet)(input, path.split("."), value);
+      return input;
+    } else {
+      return value;
+    }
+  }
+  parseSubItems(input, options) {
+    const result = { errors: [], input };
+    for (const { item, value, path } of this.getSubInputs(result.input)) {
+      const parsed = item.parse(value, options);
+      if (parsed.valid) {
+        result.input = this.updateSubItemInput(path, result.input, parsed.object);
+      } else {
+        for (const error of parsed.errors) {
+          error.field = error.field ? `${path}.${error.field}` : path;
+          result.errors.push(error);
+        }
+        if (options == null ? void 0 : options.fast) {
+          break;
+        }
       }
-    });
-    return this;
+    }
+    return result;
   }
 };
 __decorateClass([
   parsable()
-], _SchemaItem.prototype, "in", 1);
+], _SchemaItem.prototype, "parseJSON", 1);
 __decorateClass([
   parsable()
-], _SchemaItem.prototype, "parseJSON", 1);
+], _SchemaItem.prototype, "in", 1);
 var SchemaItem = _SchemaItem;
 
 // src/items/array.ts
@@ -285,14 +287,14 @@ var SchemaArray = class extends SchemaItem {
     this.addPreProcess((it) => typeof it === "string" ? it.split(separator) : it);
     return this;
   }
-  getSubInputs(input) {
-    return Array.isArray(input) ? input.map((e, i) => ({ item: this.values, value: e, path: i.toString() })) : [];
-  }
   unwrap() {
     return this.values;
   }
   isOfType(input) {
-    return Array.isArray(input) && input.every((e) => this.values.isOfType(e));
+    return Array.isArray(input) && input.every((entry) => this.values.isOfType(entry));
+  }
+  getSubInputs(input) {
+    return Array.isArray(input) ? input.map((entry, index) => ({ item: this.values, value: entry, path: index.toString() })) : [];
   }
 };
 __decorateClass([
@@ -340,6 +342,9 @@ var SchemaNullable = class extends SchemaItem {
   unwrap() {
     return this.child;
   }
+  isOfType(input) {
+    return typeof input === "undefined" || this.child.isOfType(input);
+  }
   getSubInputs(input) {
     return [{ value: input, item: this.child, path: void 0 }];
   }
@@ -349,9 +354,6 @@ var SchemaNullable = class extends SchemaItem {
     }
     return super.parseSubItems(input, options);
   }
-  isOfType(input) {
-    return typeof input === "undefined" || this.child.isOfType(input);
-  }
 };
 __decorateClass([
   parsable()
@@ -365,14 +367,11 @@ var SchemaObject = class extends SchemaItem {
     this.model = model;
     this.id = "object";
   }
-  getSubInputs(input) {
-    return (0, import_object_util2.isObject)(input) ? (0, import_object_util2.objectMap)(
-      input,
-      (v, k) => this.model[k] ? { item: this.model[k], value: v, path: k.toString() } : void 0
-    ).filter((e) => !isNull(e)) : [];
-  }
   isOfType(input) {
-    return (0, import_object_util2.isObject)(input) && !(0, import_object_util2.objectFind)(this.model, (item, k) => !item.isOfType(input[k]));
+    return (0, import_object_util2.isObject)(input) && !(0, import_object_util2.objectFind)(this.model, (item, key) => !item.isOfType(input[key]));
+  }
+  getSubInputs(input) {
+    return (0, import_object_util2.isObject)(input) ? (0, import_object_util2.objectMap)(this.model, (schema, key) => ({ item: schema, value: input[key], path: key.toString() })) : [];
   }
 };
 
@@ -380,19 +379,23 @@ var SchemaObject = class extends SchemaItem {
 function isNull(value) {
   return typeof value === "undefined" || value === null;
 }
-function parseQuery(model, query, opts) {
+function parseQuery(schema, query, opts) {
   const record = {};
   for (const [key, value] of query) {
-    const hasMultipleValues = query.getAll(key).length > 1;
-    (0, import_object_util3.objectSet)(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), hasMultipleValues ? query.getAll(key) : value);
+    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;
+    (0, import_object_util3.objectSet)(record, keys, finalValue);
   }
-  return model.parse(record, opts);
+  return schema.parse(record, opts);
 }
 function parseFormData(schema, data, opts) {
   const record = {};
   for (const [key, value] of data) {
-    const hasMultipleValues = data.getAll(key).length > 1;
-    (0, import_object_util3.objectSet)(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), hasMultipleValues ? data.getAll(key) : value);
+    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;
+    (0, import_object_util3.objectSet)(record, keys, finalValue);
   }
   const handleBoolean = (value, keys) => {
     var _a;
@@ -425,6 +428,27 @@ function parseFormData(schema, data, opts) {
 function parseForm(model, form, opts) {
   return parseFormData(model, new FormData(form), opts);
 }
+function getSchemaItemAtPath(schema, path) {
+  let current = schema;
+  const internalPath = (0, import_object_util3.objectClone)(path);
+  for (const key of path) {
+    if (!current) {
+      return void 0;
+    }
+    internalPath.shift();
+    while (current instanceof SchemaNullable || current instanceof SchemaDefault) {
+      current = current.unwrap();
+    }
+    if (current instanceof SchemaObject) {
+      current = current.model[key];
+      current = getSchemaItemAtPath(current, internalPath);
+    }
+  }
+  while (current instanceof SchemaNullable || current instanceof SchemaDefault) {
+    current = current.unwrap();
+  }
+  return current;
+}
 
 // src/items/any.ts
 var SchemaAny = class extends SchemaItem {
@@ -440,7 +464,7 @@ var SchemaDate = class extends SchemaItem {
       if (typeof input !== "string") {
         return input;
       }
-      let date = void 0;
+      let date;
       switch (format) {
         case "default": {
           date = new Date(input);
@@ -487,6 +511,9 @@ var SchemaRecord = class extends SchemaItem {
     this.keys = keys;
     this.values = values;
   }
+  isOfType(input) {
+    return (0, import_object_util4.isObject)(input) && Object.prototype.toString.call(input) === "[object Object]";
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     if ((0, import_object_util4.isObject)(input)) {
@@ -509,9 +536,6 @@ var SchemaRecord = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return (0, import_object_util4.isObject)(input) && Object.prototype.toString.call(input) === "[object Object]";
-  }
 };
 
 // src/items/enum.ts
@@ -585,7 +609,7 @@ var SchemaNumber = class extends SchemaItem {
     return this;
   }
   parseString() {
-    this.addPreProcess((input) => typeof input === "string" ? parseFloat(input) : input);
+    this.addPreProcess((input) => typeof input === "string" ? Number.parseFloat(input) : input);
     return this;
   }
   isOfType(input) {
@@ -689,6 +713,9 @@ var SchemaUnion = class extends SchemaItem {
     super(schemas);
     this.schemas = schemas;
   }
+  isOfType(input) {
+    return this.schemas.some((it) => it.isOfType(input));
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     for (const schema of this.schemas) {
@@ -701,9 +728,6 @@ var SchemaUnion = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return this.schemas.some((it) => it.isOfType(input));
-  }
 };
 
 // src/items/intersection.ts
@@ -713,6 +737,9 @@ var SchemaIntersection = class extends SchemaItem {
     super(schemas);
     this.schemas = schemas;
   }
+  isOfType(input) {
+    return this.schemas.every((it) => it.isOfType(input));
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     for (const schema of this.schemas) {
@@ -729,9 +756,6 @@ var SchemaIntersection = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return this.schemas.every((it) => it.isOfType(input));
-  }
 };
 
 // src/items/default.ts
@@ -745,12 +769,12 @@ var SchemaDefault = class extends SchemaItem {
   unwrap() {
     return this.child;
   }
-  getSubInputs(input) {
-    return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
-  }
   isOfType(input) {
     return this.child.isOfType(input);
   }
+  getSubInputs(input) {
+    return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
+  }
 };
 
 // src/items/file.ts
@@ -760,10 +784,7 @@ var SchemaFile = class extends SchemaItem {
     this.addPreProcess((input) => this.isOfType(input) && input.size > 0 ? input : void 0);
   }
   extension(ext, error) {
-    this.addValidation({ fn: (input) => {
-      var _a;
-      return (_a = input.name) == null ? void 0 : _a.endsWith(ext);
-    }, error });
+    this.addValidation({ fn: (input) => input.name.endsWith(ext), error });
     return this;
   }
   maxSize(size, error) {
@@ -787,20 +808,20 @@ var SchemaTuple = class extends SchemaItem {
     super(children);
     this.children = children;
   }
-  getSubInputs(input) {
-    return Array.isArray(input) ? this.children.map((e, i) => ({ value: input[i], item: e, path: i.toString() })) : [];
-  }
   isOfType(input) {
     if (!Array.isArray(input) || input.length > this.items.length) {
       return false;
     }
-    for (const [i, item] of this.children.entries()) {
-      if (item instanceof SchemaItem && !item.isOfType(input[i])) {
+    for (const [index, item] of this.children.entries()) {
+      if (item instanceof SchemaItem && !item.isOfType(input[index])) {
         return false;
       }
     }
     return true;
   }
+  getSubInputs(input) {
+    return Array.isArray(input) ? this.children.map((entry, index) => ({ value: input[index], item: entry, path: index.toString() })) : [];
+  }
 };
 
 // src/items/nullish.ts

package/dist/Schema.mjs

@@ -10,7 +10,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // src/helpers.ts
-import { objectGet, objectLoop, objectSet as objectSet2 } from "@dzeio/object-util";
+import { objectClone, objectGet, objectLoop, objectSet as objectSet2 } from "@dzeio/object-util";
 
 // src/SchemaItem.ts
 import { isObject, objectClean, objectSet } from "@dzeio/object-util";
@@ -33,14 +33,18 @@ var _SchemaItem = class _SchemaItem {
         };
       }
     };
-    /**
-     * keep public ?
-     */
-    this.validations = [];
     /**
      * Function calls saved for serialization
      */
     this.savedCalls = [];
+    /**
+     * list of attributes for custom works
+     */
+    this.attributes = [];
+    /**
+     * keep public ?
+     */
+    this.validations = [];
     /**
      * Pre process the variable for various reasons
      *
@@ -58,16 +62,23 @@ var _SchemaItem = class _SchemaItem {
      * note: the type of the final post-process MUST be valid
      */
     this.postProcess = [];
-    /**
-     * list of attributes for custom works
-     */
-    this.attributes = [];
     this.invalidError = "the field is invalid";
+    // eslint-disable-next-line @typescript-eslint/member-ordering, @typescript-eslint/unbound-method
     this.default = this.defaultValue;
     if (items && items.length > 0) {
       this.items = Array.isArray(items) ? items : Array.from(items);
     }
   }
+  parseJSON() {
+    this.addPreProcess((input) => {
+      try {
+        return typeof input === "string" ? JSON.parse(input) : input;
+      } catch {
+        return input;
+      }
+    });
+    return this;
+  }
   in(...values) {
     this.addValidation((input) => values.includes(input));
     return this;
@@ -101,37 +112,7 @@ var _SchemaItem = class _SchemaItem {
   array() {
     return new SchemaArray(this);
   }
-  /** Returns the sub values of the input, the schema item to handle them, and the path to it */
-  getSubInputs(_input) {
-    return [];
-  }
-  /** Sets the "part" of the input that this sub schema handles. Overrides the input with the result */
-  updateSubItemInput(path, input, value) {
-    if (path && isObject(input)) {
-      objectSet(input, path.split("."), value);
-      return input;
-    } else {
-      return value;
-    }
-  }
-  parseSubItems(input, options) {
-    const result = { errors: [], input };
-    for (const { item, value, path } of this.getSubInputs(result.input)) {
-      const parsed = item.parse(value, options);
-      if (parsed.valid) {
-        result.input = this.updateSubItemInput(path, result.input, parsed.object);
-      } else {
-        for (const error of parsed.errors) {
-          error.field = error.field ? `${path}.${error.field}` : path;
-          result.errors.push(error);
-        }
-        if (options == null ? void 0 : options.fast) {
-          break;
-        }
-      }
-    }
-    return result;
-  }
+  // eslint-disable-next-line complexity
   parse(input, options) {
     var _a, _b;
     for (const preProcess of this.preProcess) {
@@ -201,23 +182,44 @@ var _SchemaItem = class _SchemaItem {
     this.postProcess.push(fn);
     return this;
   }
-  parseJSON() {
-    this.addPreProcess((input) => {
-      try {
-        return typeof input === "string" ? JSON.parse(input) : input;
-      } catch {
-        return input;
+  /** Returns the sub values of the input, the schema item to handle them, and the path to it */
+  getSubInputs(_input) {
+    return [];
+  }
+  /** Sets the "part" of the input that this sub schema handles. Overrides the input with the result */
+  updateSubItemInput(path, input, value) {
+    if (path && isObject(input)) {
+      objectSet(input, path.split("."), value);
+      return input;
+    } else {
+      return value;
+    }
+  }
+  parseSubItems(input, options) {
+    const result = { errors: [], input };
+    for (const { item, value, path } of this.getSubInputs(result.input)) {
+      const parsed = item.parse(value, options);
+      if (parsed.valid) {
+        result.input = this.updateSubItemInput(path, result.input, parsed.object);
+      } else {
+        for (const error of parsed.errors) {
+          error.field = error.field ? `${path}.${error.field}` : path;
+          result.errors.push(error);
+        }
+        if (options == null ? void 0 : options.fast) {
+          break;
+        }
       }
-    });
-    return this;
+    }
+    return result;
   }
 };
 __decorateClass([
   parsable()
-], _SchemaItem.prototype, "in", 1);
+], _SchemaItem.prototype, "parseJSON", 1);
 __decorateClass([
   parsable()
-], _SchemaItem.prototype, "parseJSON", 1);
+], _SchemaItem.prototype, "in", 1);
 var SchemaItem = _SchemaItem;
 
 // src/items/array.ts
@@ -234,14 +236,14 @@ var SchemaArray = class extends SchemaItem {
     this.addPreProcess((it) => typeof it === "string" ? it.split(separator) : it);
     return this;
   }
-  getSubInputs(input) {
-    return Array.isArray(input) ? input.map((e, i) => ({ item: this.values, value: e, path: i.toString() })) : [];
-  }
   unwrap() {
     return this.values;
   }
   isOfType(input) {
-    return Array.isArray(input) && input.every((e) => this.values.isOfType(e));
+    return Array.isArray(input) && input.every((entry) => this.values.isOfType(entry));
+  }
+  getSubInputs(input) {
+    return Array.isArray(input) ? input.map((entry, index) => ({ item: this.values, value: entry, path: index.toString() })) : [];
   }
 };
 __decorateClass([
@@ -289,6 +291,9 @@ var SchemaNullable = class extends SchemaItem {
   unwrap() {
     return this.child;
   }
+  isOfType(input) {
+    return typeof input === "undefined" || this.child.isOfType(input);
+  }
   getSubInputs(input) {
     return [{ value: input, item: this.child, path: void 0 }];
   }
@@ -298,9 +303,6 @@ var SchemaNullable = class extends SchemaItem {
     }
     return super.parseSubItems(input, options);
   }
-  isOfType(input) {
-    return typeof input === "undefined" || this.child.isOfType(input);
-  }
 };
 __decorateClass([
   parsable()
@@ -314,14 +316,11 @@ var SchemaObject = class extends SchemaItem {
     this.model = model;
     this.id = "object";
   }
-  getSubInputs(input) {
-    return isObject2(input) ? objectMap(
-      input,
-      (v, k) => this.model[k] ? { item: this.model[k], value: v, path: k.toString() } : void 0
-    ).filter((e) => !isNull(e)) : [];
-  }
   isOfType(input) {
-    return isObject2(input) && !objectFind(this.model, (item, k) => !item.isOfType(input[k]));
+    return isObject2(input) && !objectFind(this.model, (item, key) => !item.isOfType(input[key]));
+  }
+  getSubInputs(input) {
+    return isObject2(input) ? objectMap(this.model, (schema, key) => ({ item: schema, value: input[key], path: key.toString() })) : [];
   }
 };
 
@@ -329,19 +328,23 @@ var SchemaObject = class extends SchemaItem {
 function isNull(value) {
   return typeof value === "undefined" || value === null;
 }
-function parseQuery(model, query, opts) {
+function parseQuery(schema, query, opts) {
   const record = {};
   for (const [key, value] of query) {
-    const hasMultipleValues = query.getAll(key).length > 1;
-    objectSet2(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), hasMultipleValues ? query.getAll(key) : value);
+    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;
+    objectSet2(record, keys, finalValue);
   }
-  return model.parse(record, opts);
+  return schema.parse(record, opts);
 }
 function parseFormData(schema, data, opts) {
   const record = {};
   for (const [key, value] of data) {
-    const hasMultipleValues = data.getAll(key).length > 1;
-    objectSet2(record, key.split(".").map((it) => /^\d+$/g.test(it) ? parseInt(it, 10) : it), hasMultipleValues ? data.getAll(key) : value);
+    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;
+    objectSet2(record, keys, finalValue);
   }
   const handleBoolean = (value, keys) => {
     var _a;
@@ -374,6 +377,27 @@ function parseFormData(schema, data, opts) {
 function parseForm(model, form, opts) {
   return parseFormData(model, new FormData(form), opts);
 }
+function getSchemaItemAtPath(schema, path) {
+  let current = schema;
+  const internalPath = objectClone(path);
+  for (const key of path) {
+    if (!current) {
+      return void 0;
+    }
+    internalPath.shift();
+    while (current instanceof SchemaNullable || current instanceof SchemaDefault) {
+      current = current.unwrap();
+    }
+    if (current instanceof SchemaObject) {
+      current = current.model[key];
+      current = getSchemaItemAtPath(current, internalPath);
+    }
+  }
+  while (current instanceof SchemaNullable || current instanceof SchemaDefault) {
+    current = current.unwrap();
+  }
+  return current;
+}
 
 // src/items/any.ts
 var SchemaAny = class extends SchemaItem {
@@ -389,7 +413,7 @@ var SchemaDate = class extends SchemaItem {
       if (typeof input !== "string") {
         return input;
       }
-      let date = void 0;
+      let date;
       switch (format) {
         case "default": {
           date = new Date(input);
@@ -436,6 +460,9 @@ var SchemaRecord = class extends SchemaItem {
     this.keys = keys;
     this.values = values;
   }
+  isOfType(input) {
+    return isObject3(input) && Object.prototype.toString.call(input) === "[object Object]";
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     if (isObject3(input)) {
@@ -458,9 +485,6 @@ var SchemaRecord = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return isObject3(input) && Object.prototype.toString.call(input) === "[object Object]";
-  }
 };
 
 // src/items/enum.ts
@@ -534,7 +558,7 @@ var SchemaNumber = class extends SchemaItem {
     return this;
   }
   parseString() {
-    this.addPreProcess((input) => typeof input === "string" ? parseFloat(input) : input);
+    this.addPreProcess((input) => typeof input === "string" ? Number.parseFloat(input) : input);
     return this;
   }
   isOfType(input) {
@@ -638,6 +662,9 @@ var SchemaUnion = class extends SchemaItem {
     super(schemas);
     this.schemas = schemas;
   }
+  isOfType(input) {
+    return this.schemas.some((it) => it.isOfType(input));
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     for (const schema of this.schemas) {
@@ -650,9 +677,6 @@ var SchemaUnion = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return this.schemas.some((it) => it.isOfType(input));
-  }
 };
 
 // src/items/intersection.ts
@@ -662,6 +686,9 @@ var SchemaIntersection = class extends SchemaItem {
     super(schemas);
     this.schemas = schemas;
   }
+  isOfType(input) {
+    return this.schemas.every((it) => it.isOfType(input));
+  }
   parseSubItems(input, options) {
     const result = { input, errors: [] };
     for (const schema of this.schemas) {
@@ -678,9 +705,6 @@ var SchemaIntersection = class extends SchemaItem {
     }
     return result;
   }
-  isOfType(input) {
-    return this.schemas.every((it) => it.isOfType(input));
-  }
 };
 
 // src/items/default.ts
@@ -694,12 +718,12 @@ var SchemaDefault = class extends SchemaItem {
   unwrap() {
     return this.child;
   }
-  getSubInputs(input) {
-    return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
-  }
   isOfType(input) {
     return this.child.isOfType(input);
   }
+  getSubInputs(input) {
+    return [{ item: this.child, value: isNull(input) || !this.strict && !input ? this.defaultVal : input, path: void 0 }];
+  }
 };
 
 // src/items/file.ts
@@ -709,10 +733,7 @@ var SchemaFile = class extends SchemaItem {
     this.addPreProcess((input) => this.isOfType(input) && input.size > 0 ? input : void 0);
   }
   extension(ext, error) {
-    this.addValidation({ fn: (input) => {
-      var _a;
-      return (_a = input.name) == null ? void 0 : _a.endsWith(ext);
-    }, error });
+    this.addValidation({ fn: (input) => input.name.endsWith(ext), error });
     return this;
   }
   maxSize(size, error) {
@@ -736,20 +757,20 @@ var SchemaTuple = class extends SchemaItem {
     super(children);
     this.children = children;
   }
-  getSubInputs(input) {
-    return Array.isArray(input) ? this.children.map((e, i) => ({ value: input[i], item: e, path: i.toString() })) : [];
-  }
   isOfType(input) {
     if (!Array.isArray(input) || input.length > this.items.length) {
       return false;
     }
-    for (const [i, item] of this.children.entries()) {
-      if (item instanceof SchemaItem && !item.isOfType(input[i])) {
+    for (const [index, item] of this.children.entries()) {
+      if (item instanceof SchemaItem && !item.isOfType(input[index])) {
         return false;
       }
     }
     return true;
   }
+  getSubInputs(input) {
+    return Array.isArray(input) ? this.children.map((entry, index) => ({ value: input[index], item: entry, path: index.toString() })) : [];
+  }
 };
 
 // src/items/nullish.ts

package/package.json

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