@cleverbrush/schema 1.1.11 → 3.0.0

package/dist/builders/LazySchemaBuilder.d.ts

@@ -0,0 +1,169 @@
+import { type BRAND, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult } from './SchemaBuilder.js';
+type LazySchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnType<LazySchemaBuilder<any, R>['introspect']>>;
+/**
+ * Lazy schema builder class. Allows defining recursive/self-referential schemas
+ * by wrapping a getter function that returns the target schema. The getter is
+ * called once on first validation and the result is cached.
+ *
+ * This is the primary mechanism for building recursive data structures such as
+ * tree nodes, nested menus, and threaded comments.
+ *
+ * **NOTE** TypeScript cannot infer recursive types automatically, so you must
+ * provide an explicit type annotation on the variable holding the schema:
+ *
+ * @example
+ * ```ts
+ * type TreeNode = { value: number; children: TreeNode[] };
+ *
+ * const treeNode: SchemaBuilder<TreeNode, true> = object({
+ *     value: number(),
+ *     children: array(lazy(() => treeNode))
+ * });
+ *
+ * treeNode.validate({ value: 1, children: [{ value: 2, children: [] }] });
+ * // { valid: true, object: { value: 1, children: [{ value: 2, children: [] }] } }
+ * ```
+ *
+ * @example
+ * ```ts
+ * type Comment = { text: string; replies: Comment[] };
+ *
+ * const commentSchema: SchemaBuilder<Comment, true> = object({
+ *     text: string(),
+ *     replies: array(lazy(() => commentSchema))
+ * });
+ * ```
+ */
+export declare class LazySchemaBuilder<TResult = any, TRequired extends boolean = true, TNullable extends boolean = false, THasDefault extends boolean = false, TExtensions = {}> extends SchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> {
+    #private;
+    /**
+     * @hidden
+     */
+    static create(props: LazySchemaBuilderCreateProps<any>): LazySchemaBuilder<any, true, false, false, {}>;
+    protected constructor(props: LazySchemaBuilderCreateProps<TRequired>);
+    /**
+     * Resolves the lazy schema by calling the getter (once; result is cached).
+     * After the first call subsequent calls return the cached schema instance.
+     */
+    resolve(): SchemaBuilder<TResult, any, any>;
+    /**
+     * @inheritdoc
+     */
+    introspect(): {
+        /**
+         * The getter function that returns the lazily-resolved schema.
+         * Call {@link LazySchemaBuilder.resolve} to obtain the schema instance.
+         */
+        getter: () => SchemaBuilder<TResult, any, any>;
+        type: string;
+        isRequired: boolean;
+        isNullable: boolean;
+        isReadonly: boolean;
+        preprocessors: readonly import("./SchemaBuilder.js").PreprocessorEntry<TResult>[];
+        validators: readonly import("./SchemaBuilder.js").ValidatorEntry<TResult>[];
+        requiredValidationErrorMessageProvider: ValidationErrorMessageProvider<SchemaBuilder<any, any, any, any, any>>;
+        extensions: {
+            [x: string]: unknown;
+        };
+        hasDefault: boolean;
+        defaultValue: TResult | (() => TResult) | undefined;
+        description: string | undefined;
+        schemaName: string | undefined;
+        hasCatch: boolean;
+        catchValue: TResult | (() => TResult) | undefined;
+        example: unknown;
+    };
+    /** {@inheritDoc SchemaBuilder.validate} */
+    validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
+    /** {@inheritDoc SchemaBuilder.validateAsync} */
+    validateAsync(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    /**
+     * Performs synchronous validation of the schema over `object`.
+     * Throws if any preprocessor, validator, or error message provider returns a Promise.
+     * @param context Optional `ValidationContext` settings.
+     */
+    protected _validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
+    /**
+     * Performs async validation of the schema over `object`.
+     * Supports async preprocessors, validators, and error message providers.
+     * @param context Optional `ValidationContext` settings.
+     */
+    protected _validateAsync(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    protected createFromProps<TReq extends boolean>(props: LazySchemaBuilderCreateProps<TReq>): this;
+    /**
+     * @inheritdoc
+     */
+    hasType<T>(_notUsed?: T): LazySchemaBuilder<T, true, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @inheritdoc
+     */
+    clearHasType(): LazySchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    required(errorMessage?: ValidationErrorMessageProvider): LazySchemaBuilder<TResult, true, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): LazySchemaBuilder<TResult, false, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): LazySchemaBuilder<TResult, true, TNullable, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): LazySchemaBuilder<TResult, TRequired, TNullable, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): LazySchemaBuilder<TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    readonly(): LazySchemaBuilder<Readonly<TResult>, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): LazySchemaBuilder<TResult, TRequired, true, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): LazySchemaBuilder<TResult, TRequired, false, THasDefault, TExtensions> & TExtensions;
+}
+/**
+ * Creates a lazy schema that defers the schema definition until first validation.
+ * Use this to define recursive/self-referential schemas.
+ *
+ * The getter function is called **once** on first use and the result is cached.
+ * You **must** provide an explicit TypeScript type annotation on the variable
+ * holding the outer schema — TypeScript cannot infer recursive types automatically.
+ *
+ * @param getter - A function that returns the schema to use for validation.
+ *
+ * @example
+ * ```ts
+ * // Tree structure
+ * type TreeNode = { value: number; children: TreeNode[] };
+ *
+ * const treeNode: SchemaBuilder<TreeNode, true> = object({
+ *     value: number(),
+ *     children: array(lazy(() => treeNode))
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Optional recursive field (submenu)
+ * type MenuItem = { label: string; submenu?: MenuItem[] };
+ *
+ * const menuItem: SchemaBuilder<MenuItem, true> = object({
+ *     label: string(),
+ *     submenu: array(lazy(() => menuItem)).optional()
+ * });
+ * ```
+ */
+export declare function lazy<TResult>(getter: () => SchemaBuilder<TResult, any, any>): LazySchemaBuilder<TResult, true, false, false, {}>;
+export {};

package/dist/builders/NullSchemaBuilder.d.ts

@@ -0,0 +1,162 @@
+import { type BRAND, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult } from './SchemaBuilder.js';
+type NullSchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnType<NullSchemaBuilder<R>['introspect']>>;
+/**
+ * Schema builder for `null` values. Validates that the input is exactly `null`.
+ *
+ * When required (the default), only `null` is accepted. When optional (via
+ * `.optional()`), both `null` and `undefined` are accepted; any other value
+ * is rejected.
+ *
+ * This builder is useful when you need to represent an explicitly-null field
+ * in a typed schema, for example in discriminated-union branches or when
+ * modelling a JSON payload that may carry a JSON `null` value.
+ *
+ * **NOTE** this class is exported only to give opportunity to extend it
+ * by inheriting. It is not recommended to create an instance of this class
+ * directly. Use {@link nul | nul()} function instead.
+ *
+ * @example
+ * ```ts
+ * import { nul } from '@cleverbrush/schema';
+ *
+ * const schema = nul();
+ *
+ * schema.validate(null);       // { valid: true,  object: null }
+ * schema.validate(undefined);  // { valid: false }
+ * schema.validate(0);          // { valid: false }
+ * schema.validate('');         // { valid: false }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Optional — accepts null or undefined
+ * const schema = nul().optional();
+ *
+ * schema.validate(null);       // { valid: true, object: null }
+ * schema.validate(undefined);  // { valid: true, object: undefined }
+ * schema.validate(false);      // { valid: false }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Use inside a union to model a nullable string field
+ * import { union, string, nul, InferType } from '@cleverbrush/schema';
+ *
+ * const NullableString = union(string()).or(nul());
+ * type NullableString = InferType<typeof NullableString>;
+ * // string | null
+ *
+ * NullableString.validate('hello');  // valid
+ * NullableString.validate(null);     // valid
+ * NullableString.validate(42);       // invalid
+ * ```
+ *
+ * @see {@link nul}
+ */
+export declare class NullSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TExplicitType = undefined, THasDefault extends boolean = false, TExtensions = {}> extends SchemaBuilder<null, TRequired, TNullable, THasDefault, TExtensions> {
+    #private;
+    /**
+     * @hidden
+     */
+    static create(props: NullSchemaBuilderCreateProps<any>): NullSchemaBuilder<true, false, undefined, false, {}>;
+    protected constructor(props: NullSchemaBuilderCreateProps<TRequired>);
+    /**
+     * @hidden
+     */
+    hasType<T>(_notUsed?: T): NullSchemaBuilder<true, TNullable, T, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearHasType(): NullSchemaBuilder<TRequired, TNullable, undefined, THasDefault, TExtensions> & TExtensions;
+    /** {@inheritDoc SchemaBuilder.validate} */
+    validate(object: null, context?: ValidationContext): ValidationResult<null>;
+    /** {@inheritDoc SchemaBuilder.validateAsync} */
+    validateAsync(object: null, context?: ValidationContext): Promise<ValidationResult<null>>;
+    /**
+     * Performs synchronous validation of the schema over `object`.
+     * @param context Optional `ValidationContext` settings.
+     */
+    protected _validate(object: null, _context?: ValidationContext): ValidationResult<null>;
+    /**
+     * Performs async validation of the schema over `object`.
+     * @param context Optional `ValidationContext` settings.
+     */
+    protected _validateAsync(object: null, _context?: ValidationContext): Promise<ValidationResult<null>>;
+    protected createFromProps<TReq extends boolean>(props: NullSchemaBuilderCreateProps<TReq>): this;
+    /**
+     * @hidden
+     */
+    required(errorMessage?: ValidationErrorMessageProvider): NullSchemaBuilder<true, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): NullSchemaBuilder<false, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: null | (() => null)): NullSchemaBuilder<true, TNullable, TExplicitType, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): NullSchemaBuilder<TRequired, TNullable, TExplicitType, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): NullSchemaBuilder<TRequired, TNullable, null & {
+        readonly [K in BRAND]: TBrand;
+    }, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `Readonly<null>`. Since `null` is already
+     * immutable this is an identity operation, but it sets the `isReadonly`
+     * introspection flag for tooling consistency.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): NullSchemaBuilder<TRequired, TNullable, Readonly<null>, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): NullSchemaBuilder<TRequired, true, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): NullSchemaBuilder<TRequired, false, TExplicitType, THasDefault, TExtensions> & TExtensions;
+}
+/**
+ * Creates a schema that validates the value is exactly `null`.
+ *
+ * By default the schema is **required** — only `null` is accepted.
+ * Call `.optional()` to also allow `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { nul } from '@cleverbrush/schema';
+ *
+ * nul().validate(null);       // { valid: true,  object: null }
+ * nul().validate(undefined);  // { valid: false }
+ * nul().validate(0);          // { valid: false }
+ * ```
+ *
+ * @example
+ * ```ts
+ * nul().optional().validate(null);       // { valid: true, object: null }
+ * nul().optional().validate(undefined);  // { valid: true, object: undefined }
+ * nul().optional().validate(false);      // { valid: false }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Nullable field in an object schema
+ * import { object, string, nul, union, InferType } from '@cleverbrush/schema';
+ *
+ * const Schema = object({
+ *   name:    string(),
+ *   deleted: union(nul()).or(string()),   // null | string
+ * });
+ *
+ * type T = InferType<typeof Schema>;
+ * // { name: string; deleted: null | string }
+ * ```
+ */
+export declare const nul: () => NullSchemaBuilder<true>;
+export {};

package/dist/builders/NumberSchemaBuilder.d.ts

@@ -1,5 +1,5 @@
-import { Preprocessor, SchemaBuilder, ValidationResult, ValidationContext, Validator } from './SchemaBuilder.js';
-type NumberSchemaBuilderCreateProps<T = number, R extends boolean = true> = Partial<ReturnType<NumberSchemaBuilder<T, R>['introspect']>>;
+import { type BRAND, type PreprocessorEntry, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult, type ValidatorEntry } from './SchemaBuilder.js';
+type NumberSchemaBuilderCreateProps<T = number, R extends boolean = true> = Partial<ReturnType<NumberSchemaBuilder<T, R, any>['introspect']>>;
 /**
  * Number schema builder class. Allows to create Number schemas.
  * Can be required or optional, can be restricted to be equal to a certain value,
@@ -11,143 +11,271 @@ type NumberSchemaBuilderCreateProps<T = number, R extends boolean = true> = Part
  *
  * @example ```ts
  * const schema = number().equals(42);
- * const result = await schema.validate(42);
+ * const result = schema.validate(42);
  * // result.valid === true
  * // result.object === 42
  * ```
  * @example ```ts
  * const schema = number();
- * const result = await schema.validate('42');
+ * const result = schema.validate('42');
  * // result.valid === false
  * // result.errors[0].message === 'is expected to be a number'
  * ```
  * @example ```ts
  * const schema = number().min(0).max(100);
- * const result = await schema.validate(42);
+ * const result = schema.validate(42);
  * // result.valid === true
  * // result.object === 42
  * ```
  *
  * @example ```ts
  * const schema = number().min(0).max(100);
- * const result = await schema.validate(142.5);
+ * const result = schema.validate(142.5);
  * // result.valid === false
  * // result.errors[0].message === 'is expected to be less than or equal to 100'
  * ```
  *
  * @see {@link number}
  */
-export declare class NumberSchemaBuilder<TResult = number, TRequired extends boolean = true> extends SchemaBuilder<TResult, TRequired> {
+export declare class NumberSchemaBuilder<TResult = number, TRequired extends boolean = true, TNullable extends boolean = false, THasDefault extends boolean = false, TExtensions = {}> extends SchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> {
     #private;
-    static create(props: NumberSchemaBuilderCreateProps): NumberSchemaBuilder<number, true>;
-    private constructor();
+    /**
+     * @hidden
+     */
+    static create(props: NumberSchemaBuilderCreateProps): NumberSchemaBuilder<number, true, false, false, {}>;
+    protected constructor(props: NumberSchemaBuilderCreateProps);
     introspect(): {
         /**
          * Min valid value (if defined).
          */
         min: number | undefined;
+        /**
+         * Min valid value error message provider.
+         * If not provided, default error message will be used.
+         */
+        minValidationErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Max valid value (if defined).
          */
         max: number | undefined;
+        /**
+         * Max valid value error message provider.
+         * If not provided, default error message will be used.
+         */
+        maxValidationErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Make sure that object is not `NaN`. `true` by default.
          */
         ensureNotNaN: boolean;
+        /**
+         * EnsureNotNaN error message provider.
+         * If not provided, default error message will be used.
+         */
+        ensureNotNaNErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Make sure that object is not different kinds of `infinity`. `true` by default.
          */
         ensureIsFinite: boolean;
+        /**
+         * EnsureIsFinite error message provider.
+         */
+        ensureIsFiniteErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * If set, restrict object to be equal to a certain value.
          */
         equalsTo: number | undefined;
+        /**
+         * EqualsTo error message provider.
+         * If not provided, default error message will be used.
+         */
+        equalsToValidationErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Allow only integer values (floating point values will be rejected
          * as invalid)
          */
         isInteger: boolean;
+        /**
+         * EnsureIsInteger error message provider.
+         */
+        ensureIsIntegerErrorMessageProvider: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired, false, false, {}>>;
         /**
          * Array of preprocessor functions
          */
-        preprocessors: Preprocessor<TResult>[];
+        preprocessors: PreprocessorEntry<TResult>[];
         /**
          * Array of validator functions
          */
-        validators: Validator<TResult>[];
+        validators: ValidatorEntry<TResult>[];
         type: string;
         isRequired: boolean;
+        isNullable: boolean;
+        isReadonly: boolean;
+        requiredValidationErrorMessageProvider: ValidationErrorMessageProvider<SchemaBuilder<any, any, any, any, any>>;
+        extensions: {
+            [x: string]: unknown;
+        };
+        hasDefault: boolean;
+        defaultValue: TResult | (() => TResult) | undefined;
+        description: string | undefined;
+        schemaName: string | undefined;
+        hasCatch: boolean;
+        catchValue: TResult | (() => TResult) | undefined;
+        example: unknown;
     };
     /**
-     * @hidden
+     * @inheritdoc
      */
-    hasType<T>(notUsed?: T): NumberSchemaBuilder<T, true>;
+    hasType<T>(_notUsed?: T): NumberSchemaBuilder<T, true, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
-     * @hidden
+     * @inheritdoc
      */
-    clearHasType(): NumberSchemaBuilder<number, TRequired>;
+    clearHasType(): NumberSchemaBuilder<number, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /** {@inheritDoc SchemaBuilder.validate} */
+    validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
+    /** {@inheritDoc SchemaBuilder.validateAsync} */
+    validateAsync(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
     /**
-     * Performs validion of number schema over `object`.
+     * Performs synchronous validation of number schema over `object`.
+     * Throws if any preprocessor, validator, or error message provider returns a Promise.
      * @param context Optional `ValidationContext` settings.
      */
-    validate(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    protected _validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
+    /**
+     * Performs async validation of number schema over `object`.
+     * Supports async preprocessors, validators, and error message providers.
+     * @param context Optional `ValidationContext` settings.
+     */
+    protected _validateAsync(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
     protected createFromProps<T, TReq extends boolean>(props: NumberSchemaBuilderCreateProps<T, TReq>): this;
     /**
      * Restricts number to be equal to `value`.
      */
-    equals<T extends number>(value: T): NumberSchemaBuilder<T, TRequired>;
+    equals<T extends number>(value: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<T, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Clear `equals()` call.
      */
-    clearEquals(): NumberSchemaBuilder<number, TRequired>;
+    clearEquals(): NumberSchemaBuilder<number, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
+     * @deprecated Use {@link clearIsInteger} instead.
      * Float values will be considered as valid after this call.
      */
-    isFloat(): NumberSchemaBuilder<TResult, TRequired>;
+    isFloat(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Clear `isInteger()` call.
+     */
+    clearIsInteger(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Only integer values will be considered as valid after this call.
      */
-    isInteger(): NumberSchemaBuilder<TResult, TRequired>;
+    isInteger(
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * @hidden
      */
-    required(): NumberSchemaBuilder<TResult, true>;
+    required(errorMessage?: ValidationErrorMessageProvider): NumberSchemaBuilder<TResult, true, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * @hidden
      */
-    optional(): NumberSchemaBuilder<TResult, false>;
+    optional(): NumberSchemaBuilder<TResult, false, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): NumberSchemaBuilder<TResult, true, TNullable, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): NumberSchemaBuilder<TResult, TRequired, TNullable, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): NumberSchemaBuilder<TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `Readonly<number>`. Since numbers are
+     * already immutable this is an identity operation, but it sets the
+     * `isReadonly` introspection flag for tooling consistency.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): NumberSchemaBuilder<Readonly<TResult>, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Do not accept NaN value
      */
-    notNaN(): NumberSchemaBuilder<TResult, TRequired>;
+    notNaN(
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Consider NaN value as valid
      */
-    canBeNaN(): NumberSchemaBuilder<TResult, TRequired>;
+    canBeNaN(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Do not accept `Infinity`.
      */
-    isFinite(): NumberSchemaBuilder<TResult, TRequired>;
+    isFinite(
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Consider `Infinity` as valid.
      */
-    canBeInfinite(): NumberSchemaBuilder<TResult, TRequired>;
+    canBeInfinite(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Adds a preprocessor that coerces a string value to a number
+     * using `Number(value)`. Useful when the input is captured from
+     * a string source (e.g. a parse-string schema, URL parameter,
+     * or form input).
+     *
+     * @example ```ts
+     * const schema = number().coerce();
+     * const result = schema.validate('42');
+     * // result.valid === true
+     * // result.object === 42
+     * ```
+     */
+    coerce(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Restrict number to be at least `minValue`.
      */
-    min(minValue: number): NumberSchemaBuilder<TResult, TRequired>;
+    min(minValue: number, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Clear `min()` call.
      */
-    clearMin(): NumberSchemaBuilder<TResult, TRequired>;
+    clearMin(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Restrict number to be no more than `maxValue`.
      */
-    max(maxValue: number): NumberSchemaBuilder<TResult, TRequired>;
+    max(maxValue: number, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder<TResult, TRequired>>): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
     /**
      * Clear `max()` call.
      */
-    clearMax(): NumberSchemaBuilder<TResult, TRequired>;
+    clearMax(): NumberSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): NumberSchemaBuilder<TResult, TRequired, true, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): NumberSchemaBuilder<TResult, TRequired, false, THasDefault, TExtensions> & TExtensions;
 }
 /**
  * Creates a number schema restricted to `equals` value.