@dzeio/schema 0.9.0 → 0.10.0

package/dist/Schema.d.mts

@@ -1,9 +1,10 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
 
 declare abstract class SchemaItem<Output = any, Input = Output> implements StandardSchemaV1<Input, Output> {
+    static readonly id: string;
     readonly _output: Output;
     readonly _input: Input;
-    static id: string;
+    readonly id: string;
     '~standard': StandardSchemaV1.Props<Input, Output>;
     /**
      * Function calls saved for serialization
@@ -42,6 +43,7 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     protected readonly items?: Array<unknown>;
     private invalidError;
     constructor(items?: Array<unknown> | IArguments);
+    setInvalidError(err: string): this;
     parseJSON(): this;
     /**
     * make sure the value is one of the `values`
@@ -50,7 +52,6 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     in(...values: Array<Output>): this;
     attrs(...attributes: Array<string>): this;
     attr(...attributes: Array<string>): this;
-    setInvalidError(err: string): this;
     clone(): this;
     defaultValue(value: Output, strict?: boolean): SchemaDefault<this>;
     default: (value: Output, strict?: boolean) => SchemaDefault<this>;
@@ -58,17 +59,8 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     or<Other extends SchemaItem>(other: Other): SchemaUnion<[this, Other]>;
     and<Type extends SchemaItem>(other: Type): SchemaIntersection<[this, Type]>;
     array(): SchemaArray<this>;
-    /**
-     * schemas implementing unwrap can return their child component (mostly the value)
-     *
-     * ex: s.record(s.number(), s.string()) returns s.string()
-     *
-     * es2: s.nullable(s.string()) returns s.string()
-     */
-    unwrap?(): SchemaItem;
     parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
     toJSON(): SchemaJSON;
-    private deepSerializeItem;
     addValidation(fn: ((input: Output) => boolean) | {
         fn: (input: Output) => boolean;
         error?: string;
@@ -87,6 +79,7 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
         input: unknown;
         errors?: Array<ValidationError>;
     };
+    private deepSerializeItem;
     abstract isOfType(input: unknown): input is Output;
 }
 
@@ -164,13 +157,13 @@ type ModelInfer$1<M extends Model> = {
 type Literal = string | number | bigint | boolean | null | undefined
 
 declare class SchemaAny extends SchemaItem {
-    static id: string;
+    static readonly id = "any";
     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;
+    static readonly id = "date";
     parseString(format?: DateFormat): this;
     isOfType(input: unknown): input is Date;
 }
@@ -178,8 +171,10 @@ 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;
+    static readonly id = "record";
     constructor(keys: Keys, values: Values);
+    unwrap(): Values;
+    isKeyOfType(key: unknown): boolean;
     isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
@@ -189,7 +184,7 @@ 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;
+    static readonly id = "array";
     constructor(values: Child);
     /**
      * transform the array so it only contains one of each elements
@@ -211,7 +206,7 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
 }
 
 declare class SchemaBoolean extends SchemaItem<boolean> {
-    static id: string;
+    static readonly id = "boolean";
     /**
      * @param [trueValue='true'] the truhty value (default to `'true'`)
      * @param [falseValue='false'] the falthy value (default to `'false'`)
@@ -226,14 +221,14 @@ interface EnumLike {
 }
 declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
     private readonly templateEnum;
-    static id: string;
+    static readonly id = "enum";
     private readonly type;
     constructor(templateEnum: E);
     isOfType(input: unknown): input is E[keyof E];
 }
 
 declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
-    static id: string;
+    static readonly id = "literal";
     private readonly values;
     constructor(...values: Types);
     isOfType(input: unknown): input is Types[number];
@@ -241,7 +236,7 @@ declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Typ
 
 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;
+    static readonly id = "nullable";
     constructor(child: Child);
     falsyAsNull(): this;
     emptyAsNull(): this;
@@ -260,7 +255,7 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
-    static id: string;
+    static readonly id = "number";
     /**
      * validate that the number is less or equal than {@link value}
      * @param value the maxumum value (inclusive)
@@ -299,7 +294,7 @@ type ModelInfer<M extends Record<string, SchemaItem>> = {
 };
 declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends SchemaItem<ModelInfer<T>> {
     readonly model: T;
-    static id: string;
+    static readonly id = "object";
     constructor(model: T);
     isOfType(input: unknown): input is ModelInfer<T>;
     protected getSubInputs(input: unknown): Array<{
@@ -310,7 +305,7 @@ declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends S
 }
 
 declare class SchemaString extends SchemaItem<string> {
-    static id: string;
+    static readonly id = "string";
     /**
      * force the input text to be a minimum of `value` size
      * @param value the minimum length of the text
@@ -329,7 +324,11 @@ declare class SchemaString extends SchemaItem<string> {
      */
     max(value: number, message?: string): this;
     /**
-     * the value must not be empty (`''`)
+     * trim the input text before all validations
+     */
+    trim(): this;
+    /**
+     * force the input text to be not empty (`''`)
      * @param message
      * @returns
      */
@@ -351,9 +350,10 @@ 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> {
-    static id: string;
+    static readonly id = "union";
     private readonly schemas;
     constructor(...schemas: Children);
+    unwrap(): Children;
     isOfType(input: unknown): input is Outputs;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
@@ -366,9 +366,10 @@ 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;
+    static readonly id = "intersection";
     private readonly schemas;
     constructor(...schemas: Children);
+    unwrap(): Children;
     isOfType(input: unknown): input is Outputs;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
@@ -380,7 +381,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
     private readonly child;
     private readonly defaultVal;
     private readonly strict;
-    static id: string;
+    static readonly id = "default";
     constructor(child: Child, defaultVal: Output, strict?: boolean);
     unwrap(): Child;
     isOfType(input: unknown): input is Output;
@@ -392,7 +393,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
 }
 
 declare class SchemaFile extends SchemaItem<File> {
-    static id: string;
+    static readonly id = "file";
     constructor();
     extension(ext: string, error?: string): this;
     maxSize(size: number, error?: string): this;
@@ -402,9 +403,10 @@ 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;
+    static readonly id = "tuple";
     private readonly children;
     constructor(...children: Children);
+    unwrap(): Children;
     isOfType(input: unknown): input is Outputs;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
@@ -414,23 +416,23 @@ declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToO
 }
 
 declare class SchemaUndefined extends SchemaItem<undefined> {
-    static id: string;
+    static readonly id = "undefined";
     isOfType(input: unknown): input is undefined;
 }
 declare class SchemaNull extends SchemaItem<null> {
-    static id: string;
+    static readonly id = "null";
     isOfType(input: unknown): input is null;
 }
 declare class SchemaVoid extends SchemaItem<void> {
-    static id: string;
+    static readonly id = "void";
     isOfType(input: unknown): input is void;
 }
 declare class SchemaNullish extends SchemaItem<null | undefined> {
-    static id: string;
+    static readonly id = "nullish";
     isOfType(input: unknown): input is null | undefined;
 }
 declare class SchemaNever extends SchemaItem<never> {
-    static id: string;
+    static readonly id = "never";
     isOfType(_input: unknown): _input is never;
 }
 
@@ -441,6 +443,12 @@ declare function parseQuery<T extends SchemaItem>(schema: T, query: URLSearchPar
  */
 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']>;
+/**
+ * @param schema
+ * @param path
+ * @returns the correct SchemaItem associated to a key targeted according to the indicated path
+ */
+declare function getSchemaItemAtPath(schema: SchemaItem | undefined, path: Array<string | number>): SchemaItem | undefined;
 
 /**
  * Decorator for modifier functions on SchemaItems to save them in the "savedCalls" property for the serialization
@@ -503,4 +511,4 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
 }
 declare const s: typeof Schema;
 
-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 };
+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, SchemaTuple, SchemaUndefined, SchemaUnion, SchemaVoid, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, getSchemaItemAtPath, isNull, parsable, parseForm, parseFormData, parseQuery, s };

package/dist/Schema.d.ts

@@ -1,9 +1,10 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
 
 declare abstract class SchemaItem<Output = any, Input = Output> implements StandardSchemaV1<Input, Output> {
+    static readonly id: string;
     readonly _output: Output;
     readonly _input: Input;
-    static id: string;
+    readonly id: string;
     '~standard': StandardSchemaV1.Props<Input, Output>;
     /**
      * Function calls saved for serialization
@@ -42,6 +43,7 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     protected readonly items?: Array<unknown>;
     private invalidError;
     constructor(items?: Array<unknown> | IArguments);
+    setInvalidError(err: string): this;
     parseJSON(): this;
     /**
     * make sure the value is one of the `values`
@@ -50,7 +52,6 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     in(...values: Array<Output>): this;
     attrs(...attributes: Array<string>): this;
     attr(...attributes: Array<string>): this;
-    setInvalidError(err: string): this;
     clone(): this;
     defaultValue(value: Output, strict?: boolean): SchemaDefault<this>;
     default: (value: Output, strict?: boolean) => SchemaDefault<this>;
@@ -58,17 +59,8 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
     or<Other extends SchemaItem>(other: Other): SchemaUnion<[this, Other]>;
     and<Type extends SchemaItem>(other: Type): SchemaIntersection<[this, Type]>;
     array(): SchemaArray<this>;
-    /**
-     * schemas implementing unwrap can return their child component (mostly the value)
-     *
-     * ex: s.record(s.number(), s.string()) returns s.string()
-     *
-     * es2: s.nullable(s.string()) returns s.string()
-     */
-    unwrap?(): SchemaItem;
     parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
     toJSON(): SchemaJSON;
-    private deepSerializeItem;
     addValidation(fn: ((input: Output) => boolean) | {
         fn: (input: Output) => boolean;
         error?: string;
@@ -87,6 +79,7 @@ declare abstract class SchemaItem<Output = any, Input = Output> implements Stand
         input: unknown;
         errors?: Array<ValidationError>;
     };
+    private deepSerializeItem;
     abstract isOfType(input: unknown): input is Output;
 }
 
@@ -164,13 +157,13 @@ type ModelInfer$1<M extends Model> = {
 type Literal = string | number | bigint | boolean | null | undefined
 
 declare class SchemaAny extends SchemaItem {
-    static id: string;
+    static readonly id = "any";
     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;
+    static readonly id = "date";
     parseString(format?: DateFormat): this;
     isOfType(input: unknown): input is Date;
 }
@@ -178,8 +171,10 @@ 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;
+    static readonly id = "record";
     constructor(keys: Keys, values: Values);
+    unwrap(): Values;
+    isKeyOfType(key: unknown): boolean;
     isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
@@ -189,7 +184,7 @@ 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;
+    static readonly id = "array";
     constructor(values: Child);
     /**
      * transform the array so it only contains one of each elements
@@ -211,7 +206,7 @@ declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>,
 }
 
 declare class SchemaBoolean extends SchemaItem<boolean> {
-    static id: string;
+    static readonly id = "boolean";
     /**
      * @param [trueValue='true'] the truhty value (default to `'true'`)
      * @param [falseValue='false'] the falthy value (default to `'false'`)
@@ -226,14 +221,14 @@ interface EnumLike {
 }
 declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
     private readonly templateEnum;
-    static id: string;
+    static readonly id = "enum";
     private readonly type;
     constructor(templateEnum: E);
     isOfType(input: unknown): input is E[keyof E];
 }
 
 declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Types[number]> {
-    static id: string;
+    static readonly id = "literal";
     private readonly values;
     constructor(...values: Types);
     isOfType(input: unknown): input is Types[number];
@@ -241,7 +236,7 @@ declare class SchemaLiteral<Types extends Array<Literal>> extends SchemaItem<Typ
 
 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;
+    static readonly id = "nullable";
     constructor(child: Child);
     falsyAsNull(): this;
     emptyAsNull(): this;
@@ -260,7 +255,7 @@ declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Chil
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
-    static id: string;
+    static readonly id = "number";
     /**
      * validate that the number is less or equal than {@link value}
      * @param value the maxumum value (inclusive)
@@ -299,7 +294,7 @@ type ModelInfer<M extends Record<string, SchemaItem>> = {
 };
 declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends SchemaItem<ModelInfer<T>> {
     readonly model: T;
-    static id: string;
+    static readonly id = "object";
     constructor(model: T);
     isOfType(input: unknown): input is ModelInfer<T>;
     protected getSubInputs(input: unknown): Array<{
@@ -310,7 +305,7 @@ declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends S
 }
 
 declare class SchemaString extends SchemaItem<string> {
-    static id: string;
+    static readonly id = "string";
     /**
      * force the input text to be a minimum of `value` size
      * @param value the minimum length of the text
@@ -329,7 +324,11 @@ declare class SchemaString extends SchemaItem<string> {
      */
     max(value: number, message?: string): this;
     /**
-     * the value must not be empty (`''`)
+     * trim the input text before all validations
+     */
+    trim(): this;
+    /**
+     * force the input text to be not empty (`''`)
      * @param message
      * @returns
      */
@@ -351,9 +350,10 @@ 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> {
-    static id: string;
+    static readonly id = "union";
     private readonly schemas;
     constructor(...schemas: Children);
+    unwrap(): Children;
     isOfType(input: unknown): input is Outputs;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
@@ -366,9 +366,10 @@ 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;
+    static readonly id = "intersection";
     private readonly schemas;
     constructor(...schemas: Children);
+    unwrap(): Children;
     isOfType(input: unknown): input is Outputs;
     protected parseSubItems(input: unknown, options?: ValidationOptions): {
         input: unknown;
@@ -380,7 +381,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
     private readonly child;
     private readonly defaultVal;
     private readonly strict;
-    static id: string;
+    static readonly id = "default";
     constructor(child: Child, defaultVal: Output, strict?: boolean);
     unwrap(): Child;
     isOfType(input: unknown): input is Output;
@@ -392,7 +393,7 @@ declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child
 }
 
 declare class SchemaFile extends SchemaItem<File> {
-    static id: string;
+    static readonly id = "file";
     constructor();
     extension(ext: string, error?: string): this;
     maxSize(size: number, error?: string): this;
@@ -402,9 +403,10 @@ 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;
+    static readonly id = "tuple";
     private readonly children;
     constructor(...children: Children);
+    unwrap(): Children;
     isOfType(input: unknown): input is Outputs;
     protected getSubInputs(input: unknown): Array<{
         item: SchemaItem;
@@ -414,23 +416,23 @@ declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToO
 }
 
 declare class SchemaUndefined extends SchemaItem<undefined> {
-    static id: string;
+    static readonly id = "undefined";
     isOfType(input: unknown): input is undefined;
 }
 declare class SchemaNull extends SchemaItem<null> {
-    static id: string;
+    static readonly id = "null";
     isOfType(input: unknown): input is null;
 }
 declare class SchemaVoid extends SchemaItem<void> {
-    static id: string;
+    static readonly id = "void";
     isOfType(input: unknown): input is void;
 }
 declare class SchemaNullish extends SchemaItem<null | undefined> {
-    static id: string;
+    static readonly id = "nullish";
     isOfType(input: unknown): input is null | undefined;
 }
 declare class SchemaNever extends SchemaItem<never> {
-    static id: string;
+    static readonly id = "never";
     isOfType(_input: unknown): _input is never;
 }
 
@@ -441,6 +443,12 @@ declare function parseQuery<T extends SchemaItem>(schema: T, query: URLSearchPar
  */
 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']>;
+/**
+ * @param schema
+ * @param path
+ * @returns the correct SchemaItem associated to a key targeted according to the indicated path
+ */
+declare function getSchemaItemAtPath(schema: SchemaItem | undefined, path: Array<string | number>): SchemaItem | undefined;
 
 /**
  * Decorator for modifier functions on SchemaItems to save them in the "savedCalls" property for the serialization
@@ -503,4 +511,4 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
 }
 declare const s: typeof Schema;
 
-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 };
+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, SchemaTuple, SchemaUndefined, SchemaUnion, SchemaVoid, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, getSchemaItemAtPath, isNull, parsable, parseForm, parseFormData, parseQuery, s };