@cleverbrush/schema 1.1.11 → 2.0.0

package/dist/extensions/enum.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Built-in enum extension for `@cleverbrush/schema`.
+ *
+ * Provides the `.oneOf()` method on `StringSchemaBuilder` and
+ * `NumberSchemaBuilder`, constraining the value to a fixed set of
+ * allowed literals and narrowing the inferred type accordingly.
+ *
+ * Also exports the top-level {@link enumOf} convenience factory, which is
+ * sugar for `string().oneOf(...)`.
+ *
+ * These are pre-applied in the default `@cleverbrush/schema` import.
+ * Import from `@cleverbrush/schema/core` to get bare builders without
+ * these extensions.
+ *
+ * @module
+ */
+import type { NumberSchemaBuilder } from '../builders/NumberSchemaBuilder.js';
+import type { ValidationErrorMessageProvider } from '../builders/SchemaBuilder.js';
+import type { StringSchemaBuilder } from '../builders/StringSchemaBuilder.js';
+import type { HiddenExtensionMethods } from '../extension.js';
+/** Return type for `.oneOf()` on `StringSchemaBuilder`. */
+type StringOneOfReturn<T extends string = string> = StringSchemaBuilder<T, true, false, false, StringOneOfExtension> & StringOneOfExtension & HiddenExtensionMethods;
+/** Return type for `.oneOf()` on `NumberSchemaBuilder`. */
+type NumberOneOfReturn<T extends number = number> = NumberSchemaBuilder<T, true, false, false, NumberOneOfExtension> & NumberOneOfExtension & HiddenExtensionMethods;
+/**
+ * `.oneOf()` method added to `StringSchemaBuilder` by the built-in enum
+ * extension pack.
+ *
+ * **WORKAROUND:** This interface duplicates the method signature from
+ * `enumExtension` so that JSDoc survives into the published `.d.ts`
+ * files. TypeScript strips JSDoc when method signatures are reconstructed
+ * through the `FixedMethods` mapped type (conditional `infer` loses
+ * comments). Remove this interface once TypeScript preserves JSDoc
+ * through mapped types / conditional type inference.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/50715
+ */
+export interface StringOneOfExtension {
+    /**
+     * Constrains the string to one of the specified literal values.
+     *
+     * Narrows the inferred type from `string` to the union of the
+     * provided literals.
+     *
+     * @param values - the allowed string literals
+     * @returns a new schema builder restricted to the given values
+     *
+     * @example
+     * ```ts
+     * import { string, InferType } from '@cleverbrush/schema';
+     *
+     * const role = string().oneOf('admin', 'user', 'guest');
+     * type Role = InferType<typeof role>; // 'admin' | 'user' | 'guest'
+     *
+     * role.validate('admin');  // valid
+     * role.validate('other');  // invalid — "must be one of: admin, user, guest"
+     * ```
+     */
+    oneOf<V extends string>(...values: [V, ...V[]]): StringOneOfReturn<V>;
+    /**
+     * Constrains the string to one of the specified literal values,
+     * with a custom error message or factory as the last argument.
+     *
+     * A trailing `string` or function argument is unambiguously the error
+     * message when using rest-param form.
+     *
+     * @example
+     * ```ts
+     * const role = string().oneOf('admin', 'user', (val) => `"${val}" is not allowed`);
+     * ```
+     */
+    oneOf<V extends string>(...args: [
+        ...[V, ...V[]],
+        ValidationErrorMessageProvider<StringSchemaBuilder>
+    ]): StringOneOfReturn<V>;
+    /**
+     * Constrains the string to one of the specified literal values,
+     * with an optional custom error message or factory.
+     *
+     * Pass the allowed values as an array (first argument) to provide a
+     * custom error message as the second argument.
+     *
+     * @param values - the allowed string literals as an array
+     * @param errorMessage - optional custom error message or factory function
+     * @returns a new schema builder restricted to the given values
+     *
+     * @example
+     * ```ts
+     * import { string, InferType } from '@cleverbrush/schema';
+     *
+     * const role = string().oneOf(['admin', 'user', 'guest'], 'Invalid role');
+     * role.validate('other');  // invalid — "Invalid role"
+     *
+     * const role2 = string().oneOf(['admin', 'user'], (val) => `"${val}" is not a valid role`);
+     * ```
+     */
+    oneOf<V extends string>(values: readonly [V, ...V[]], errorMessage?: ValidationErrorMessageProvider<StringSchemaBuilder>): StringOneOfReturn<V>;
+}
+/**
+ * `.oneOf()` method added to `NumberSchemaBuilder` by the built-in enum
+ * extension pack.
+ *
+ * @see StringOneOfExtension for full JSDoc rationale.
+ */
+export interface NumberOneOfExtension {
+    /**
+     * Constrains the number to one of the specified literal values.
+     *
+     * Narrows the inferred type from `number` to the union of the
+     * provided literals.
+     *
+     * @param values - the allowed number literals
+     * @returns a new schema builder restricted to the given values
+     *
+     * @example
+     * ```ts
+     * import { number, InferType } from '@cleverbrush/schema';
+     *
+     * const priority = number().oneOf(1, 2, 3);
+     * type Priority = InferType<typeof priority>; // 1 | 2 | 3
+     *
+     * priority.validate(1);  // valid
+     * priority.validate(4);  // invalid — "must be one of: 1, 2, 3"
+     * ```
+     */
+    oneOf<V extends number>(...values: [V, ...V[]]): NumberOneOfReturn<V>;
+    /**
+     * Constrains the number to one of the specified literal values,
+     * with a custom error message or factory as the last argument.
+     *
+     * Because number values are always numbers, a trailing `string` or
+     * function argument is unambiguously the error message.
+     *
+     * @param args - the allowed number literals followed by an error message
+     * @returns a new schema builder restricted to the given values
+     *
+     * @example
+     * ```ts
+     * import { number } from '@cleverbrush/schema';
+     *
+     * const priority = number().oneOf(1, 2, 3, 'Priority must be 1, 2, or 3');
+     * const priority2 = number().oneOf(1, 2, 3, (val) => `${val} is not a valid priority`);
+     * ```
+     */
+    oneOf<V extends number>(...args: [
+        ...[V, ...V[]],
+        ValidationErrorMessageProvider<NumberSchemaBuilder>
+    ]): NumberOneOfReturn<V>;
+    /**
+     * Constrains the number to one of the specified literal values,
+     * with an optional custom error message or factory.
+     *
+     * Pass the allowed values as an array (first argument) to provide a
+     * custom error message as the second argument.
+     *
+     * @param values - the allowed number literals as an array
+     * @param errorMessage - optional custom error message or factory function
+     * @returns a new schema builder restricted to the given values
+     *
+     * @example
+     * ```ts
+     * import { number } from '@cleverbrush/schema';
+     *
+     * const priority = number().oneOf([1, 2, 3], 'Must be 1, 2, or 3');
+     * ```
+     */
+    oneOf<V extends number>(values: readonly [V, ...V[]], errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberOneOfReturn<V>;
+}
+/**
+ * Extension descriptor that adds `.oneOf()` to `StringSchemaBuilder`
+ * and `NumberSchemaBuilder`.
+ *
+ * @example
+ * ```ts
+ * import { withExtensions } from '@cleverbrush/schema/core';
+ * import { enumExtension } from '@cleverbrush/schema';
+ *
+ * const s = withExtensions(enumExtension);
+ * const role = s.string().oneOf('admin', 'user', 'guest');
+ * ```
+ */
+export declare const enumExtension: import("../extension.js").ExtensionDescriptor<{
+    string: {
+        oneOf(this: StringSchemaBuilder, ...args: any[]): StringSchemaBuilder<string, true, false, false, {}>;
+    };
+    number: {
+        oneOf(this: NumberSchemaBuilder, ...args: any[]): NumberSchemaBuilder<number, true, false, false, {}>;
+    };
+}>;
+export {};

package/dist/extensions/index.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Pre‑wired extension pack for `@cleverbrush/schema`.
+ *
+ * Combines {@link stringExtensions}, {@link numberExtensions},
+ * and {@link arrayExtensions} via
+ * `withExtensions()` and re‑exports the augmented factory functions.
+ *
+ * The default `@cleverbrush/schema` entry point re‑exports these
+ * augmented factories so that `email()`, `positive()`, `nonempty()`,
+ * `.nullable()`, etc. are available without any setup.
+ *
+ * @module
+ */
+import type { AnySchemaBuilder } from '../builders/AnySchemaBuilder.js';
+import type { ArraySchemaBuilder } from '../builders/ArraySchemaBuilder.js';
+import type { BooleanSchemaBuilder } from '../builders/BooleanSchemaBuilder.js';
+import type { DateSchemaBuilder } from '../builders/DateSchemaBuilder.js';
+import type { FunctionSchemaBuilder } from '../builders/FunctionSchemaBuilder.js';
+import type { NumberSchemaBuilder } from '../builders/NumberSchemaBuilder.js';
+import type { ObjectSchemaBuilder } from '../builders/ObjectSchemaBuilder.js';
+import type { RecordSchemaBuilder } from '../builders/RecordSchemaBuilder.js';
+import type { SchemaBuilder, ValidationErrorMessageProvider } from '../builders/SchemaBuilder.js';
+import type { StringSchemaBuilder } from '../builders/StringSchemaBuilder.js';
+import type { TupleSchemaBuilder } from '../builders/TupleSchemaBuilder.js';
+import type { UnionSchemaBuilder } from '../builders/UnionSchemaBuilder.js';
+import type { HiddenExtensionMethods } from '../extension.js';
+import type { ArrayBuiltinExtensions } from './array.js';
+import type { NumberBuiltinExtensions } from './number.js';
+import type { StringBuiltinExtensions } from './string.js';
+export { type ArrayBuiltinExtensions, arrayExtensions } from './array.js';
+export { type NumberBuiltinExtensions, type NumberOneOfExtension, numberExtensions } from './number.js';
+export { type StringBuiltinExtensions, type StringOneOfExtension, stringExtensions } from './string.js';
+/** A `StringSchemaBuilder` with built-in extension methods. */
+export type ExtendedString<T extends string = string> = StringSchemaBuilder<T, true, false, false, StringBuiltinExtensions<T>> & StringBuiltinExtensions<T> & HiddenExtensionMethods;
+/** A `NumberSchemaBuilder` with built-in extension methods. */
+export type ExtendedNumber<T extends number = number> = NumberSchemaBuilder<T, true, false, false, NumberBuiltinExtensions<T>> & NumberBuiltinExtensions<T> & HiddenExtensionMethods;
+/** An `ArraySchemaBuilder` with built-in extension methods. */
+export type ExtendedArray<TElementSchema extends SchemaBuilder<any, any, any, any, any> = SchemaBuilder<any, any, any>> = ArraySchemaBuilder<TElementSchema, true, false, undefined, false, ArrayBuiltinExtensions<TElementSchema>> & ArrayBuiltinExtensions<TElementSchema> & HiddenExtensionMethods;
+/** A `BooleanSchemaBuilder` with built-in extension methods. */
+export type ExtendedBoolean = BooleanSchemaBuilder<boolean, true, false, undefined, false, {}> & HiddenExtensionMethods;
+/** A `DateSchemaBuilder` with built-in extension methods. */
+export type ExtendedDate = DateSchemaBuilder<Date, true, false, false, {}> & HiddenExtensionMethods;
+/** An `ObjectSchemaBuilder` with built-in extension methods. */
+export type ExtendedObject<TProps extends Record<string, SchemaBuilder<any, any, any, any, any>> = {}> = ObjectSchemaBuilder<TProps, true, false, undefined, false, {}> & HiddenExtensionMethods;
+/** A `UnionSchemaBuilder` with built-in extension methods. */
+export type ExtendedUnion<TOptions extends readonly SchemaBuilder<any, any, any, any, any>[]> = UnionSchemaBuilder<TOptions, true, false, undefined, false, {}> & HiddenExtensionMethods;
+/** A `FunctionSchemaBuilder` with built-in extension methods. */
+export type ExtendedFunc = FunctionSchemaBuilder<true, false, undefined, false, {}> & HiddenExtensionMethods;
+/** An `AnySchemaBuilder` with built-in extension methods. */
+export type ExtendedAny = AnySchemaBuilder<true, false, undefined, false, {}> & HiddenExtensionMethods;
+/** A `TupleSchemaBuilder` with built-in extension methods. */
+export type ExtendedTuple<TElements extends readonly SchemaBuilder<any, any, any>[] = readonly SchemaBuilder<any, any, any, any, any>[]> = TupleSchemaBuilder<TElements, true, false, undefined, false, {}> & HiddenExtensionMethods;
+/** A `RecordSchemaBuilder` with built-in extension methods. */
+export type ExtendedRecord<TKeySchema extends StringSchemaBuilder<any, any, any, any> = StringSchemaBuilder<any, any, any, any>, TValueSchema extends SchemaBuilder<any, any, any, any, any> = SchemaBuilder<any, any, any>> = RecordSchemaBuilder<TKeySchema, TValueSchema, true, false, undefined, false, {}> & HiddenExtensionMethods;
+export declare const string: {
+    (): ExtendedString;
+    <T extends string>(equals: T): ExtendedString<T>;
+};
+export declare const number: {
+    (): ExtendedNumber;
+    <T extends number>(equals: T): ExtendedNumber<T>;
+};
+export declare const array: <TElementSchema extends SchemaBuilder<any, any, any, any, any>>(elementSchema?: TElementSchema) => ExtendedArray<TElementSchema>;
+export declare const boolean: () => ExtendedBoolean;
+export declare const date: () => ExtendedDate;
+export declare const object: {
+    (): ExtendedObject<{}>;
+    <TProps extends Record<string, SchemaBuilder<any, any, any, any, any>>>(props: TProps): ExtendedObject<TProps>;
+    <TProps extends Record<string, SchemaBuilder<any, any, any, any, any>>>(props?: TProps): ExtendedObject<TProps>;
+};
+export declare const union: <TOptions extends SchemaBuilder<any, any, any, any, any>>(schema: TOptions) => ExtendedUnion<[TOptions]>;
+export declare const func: () => ExtendedFunc;
+export declare const any: () => ExtendedAny;
+export declare const tuple: <const TElements extends readonly SchemaBuilder<any, any, any, any, any>[]>(elements: [...TElements]) => ExtendedTuple<TElements>;
+export declare const record: <TKeySchema extends StringSchemaBuilder<any, any, any, any>, TValueSchema extends SchemaBuilder<any, any, any, any, any>>(keySchema: TKeySchema, valueSchema: TValueSchema) => ExtendedRecord<TKeySchema, TValueSchema>;
+/**
+ * Creates a string schema constrained to the given literal values.
+ *
+ * Convenience factory equivalent to `string().oneOf(...values)`.
+ * Mirrors Zod's `z.enum(['admin', 'user', 'guest'])` API.
+ *
+ * **Rest-params form** (no custom error message):
+ * ```ts
+ * const Role = enumOf('admin', 'user', 'guest');
+ * ```
+ *
+ * **Array form** (with optional custom error message):
+ * ```ts
+ * const Role = enumOf(['admin', 'user', 'guest'], 'Invalid role');
+ * const Role2 = enumOf(['admin', 'user'], (val) => `"${val}" is not a valid role`);
+ * ```
+ *
+ * @param values - the allowed string literals (at least one required)
+ * @returns a typed `StringSchemaBuilder` that only accepts the given values
+ *
+ * @example
+ * ```ts
+ * import { enumOf, InferType } from '@cleverbrush/schema';
+ *
+ * const Role = enumOf('admin', 'user', 'guest');
+ * type Role = InferType<typeof Role>; // 'admin' | 'user' | 'guest'
+ *
+ * Role.validate('admin');  // valid
+ * Role.validate('other');  // invalid
+ * ```
+ */
+export declare function enumOf<const T extends string>(...values: [T, ...T[]]): ExtendedString<T>;
+export declare function enumOf<const T extends string>(values: readonly [T, ...T[]], errorMessage?: ValidationErrorMessageProvider<StringSchemaBuilder>): ExtendedString<T>;

package/dist/extensions/nullable.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Deprecated nullable extension types for `@cleverbrush/schema`.
+ *
+ * `nullable()` and `notNullable()` are now first-class methods on
+ * `SchemaBuilder`. These types are kept for backward compatibility
+ * but will be removed in a future major version.
+ *
+ * @module
+ * @deprecated Use the first-class `.nullable()` / `.notNullable()` methods
+ * on `SchemaBuilder` instead.
+ */
+import type { NullSchemaBuilder } from '../builders/NullSchemaBuilder.js';
+import type { SchemaBuilder } from '../builders/SchemaBuilder.js';
+import type { UnionSchemaBuilder } from '../builders/UnionSchemaBuilder.js';
+/**
+ * @deprecated `nullable()` is now a first-class method on `SchemaBuilder`.
+ * This type is kept for backward compatibility only.
+ */
+export type NullableReturn<TBuilder extends SchemaBuilder<any, any, any>> = UnionSchemaBuilder<[TBuilder, NullSchemaBuilder<true>]>;
+/**
+ * @deprecated `nullable()` is now a first-class method on `SchemaBuilder`.
+ * This type is kept for backward compatibility only.
+ */
+export interface NullableMethod<TBuilder extends SchemaBuilder<any, any, any>> {
+    nullable(): NullableReturn<TBuilder>;
+}

package/dist/extensions/number.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Built-in number extensions for `@cleverbrush/schema`.
+ *
+ * Provides common number validators: {@link numberExtensions | positive},
+ * {@link numberExtensions | negative}, {@link numberExtensions | finite},
+ * {@link numberExtensions | multipleOf}, and {@link numberExtensions | oneOf}.
+ *
+ * These are pre-applied in the default `@cleverbrush/schema` import.
+ * Import from `@cleverbrush/schema/core` to get bare builders without these extensions.
+ *
+ * @module
+ */
+import type { NumberSchemaBuilder } from '../builders/NumberSchemaBuilder.js';
+import type { ValidationErrorMessageProvider } from '../builders/SchemaBuilder.js';
+import type { HiddenExtensionMethods } from '../extension.js';
+/** Return type shared by every method on {@link NumberBuiltinExtensions}. */
+type NumberExtReturn<T extends number = number> = NumberSchemaBuilder<T, true, false, false, NumberBuiltinExtensions<T>> & NumberBuiltinExtensions<T> & HiddenExtensionMethods;
+/**
+ * Methods added to `NumberSchemaBuilder` by the built-in number extension pack.
+ *
+ * **WORKAROUND:** This interface duplicates the method signatures from
+ * `numberExtensions` so that JSDoc survives into the published `.d.ts`
+ * files. TypeScript strips JSDoc when method signatures are reconstructed
+ * through the `FixedMethods` mapped type (conditional `infer` loses
+ * comments). Remove this interface once TypeScript preserves JSDoc
+ * through mapped types / conditional type inference.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/50715
+ */
+export interface NumberBuiltinExtensions<T extends number = number> {
+    /**
+     * Validates that the number is strictly greater than zero.
+     *
+     * @param errorMessage - custom error message or function to generate one
+     * @returns a new schema builder with the positive validator applied
+     *
+     * @example
+     * ```ts
+     * number().positive();
+     * number().positive('Must be greater than zero');
+     * ```
+     */
+    positive(errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberExtReturn<T>;
+    /**
+     * Validates that the number is strictly less than zero.
+     *
+     * @param errorMessage - custom error message or function to generate one
+     * @returns a new schema builder with the negative validator applied
+     *
+     * @example
+     * ```ts
+     * number().negative();
+     * number().negative('Must be below zero');
+     * ```
+     */
+    negative(errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberExtReturn<T>;
+    /**
+     * Validates that the number is finite (rejects `Infinity` and `-Infinity`).
+     *
+     * @param errorMessage - custom error message or function to generate one
+     * @returns a new schema builder with the finite validator applied
+     *
+     * @example
+     * ```ts
+     * number().finite();
+     * number().finite('No infinities allowed');
+     * ```
+     */
+    finite(errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberExtReturn<T>;
+    /**
+     * Validates that the number is an exact multiple of `n`.
+     *
+     * Uses a relative tolerance of `1e-10` for float-safe comparison.
+     *
+     * @param n - the divisor to check against
+     * @param errorMessage - custom error message or function to generate one
+     * @returns a new schema builder with the multipleOf validator applied
+     *
+     * @example
+     * ```ts
+     * number().multipleOf(5);
+     * number().multipleOf(0.1, 'Must be a multiple of 0.1');
+     * ```
+     */
+    multipleOf(n: number, errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberExtReturn<T>;
+    /**
+     * Constrains the number to one of the specified literal values.
+     *
+     * Narrows the inferred type from `number` to the union of the
+     * provided literals.
+     *
+     * @param values - the allowed number literals
+     * @returns a new schema builder restricted to the given values
+     *
+     * @example
+     * ```ts
+     * import { number, InferType } from '@cleverbrush/schema';
+     *
+     * const priority = number().oneOf(1, 2, 3);
+     * type Priority = InferType<typeof priority>; // 1 | 2 | 3
+     *
+     * priority.validate(1);  // valid
+     * priority.validate(4);  // invalid — "must be one of: 1, 2, 3"
+     * ```
+     */
+    oneOf<V extends number>(...values: [V, ...V[]]): NumberExtReturn<V>;
+    /**
+     * Constrains the number to one of the specified literal values,
+     * with a custom error message or factory as the last argument.
+     *
+     * @example
+     * ```ts
+     * const priority = number().oneOf(1, 2, 3, 'Priority must be 1, 2, or 3');
+     * const priority2 = number().oneOf(1, 2, 3, (val) => `${val} is not a valid priority`);
+     * ```
+     */
+    oneOf<V extends number>(...args: [
+        ...[V, ...V[]],
+        ValidationErrorMessageProvider<NumberSchemaBuilder>
+    ]): NumberExtReturn<V>;
+    /**
+     * Constrains the number to one of the specified literal values,
+     * with an optional custom error message or factory.
+     *
+     * @param values - the allowed number literals as an array
+     * @param errorMessage - optional custom error message or factory function
+     * @returns a new schema builder restricted to the given values
+     *
+     * @example
+     * ```ts
+     * const priority = number().oneOf([1, 2, 3], 'Must be 1, 2, or 3');
+     * ```
+     */
+    oneOf<V extends number>(values: readonly [V, ...V[]], errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberExtReturn<V>;
+}
+/**
+ * Subset of {@link NumberBuiltinExtensions} containing only the `.oneOf()` overloads.
+ * Exported for backward compatibility.
+ */
+export type NumberOneOfExtension = Pick<NumberBuiltinExtensions, 'oneOf'>;
+/**
+ * Extension descriptor that adds common number validators
+ * to `NumberSchemaBuilder`.
+ *
+ * Included methods: `positive`, `negative`, `finite`, `multipleOf`, `oneOf`.
+ *
+ * @example
+ * ```ts
+ * import { withExtensions } from '@cleverbrush/schema/core';
+ * import { numberExtensions } from '@cleverbrush/schema';
+ *
+ * const s = withExtensions(numberExtensions);
+ * const schema = s.number().positive().multipleOf(5);
+ * ```
+ */
+export declare const numberExtensions: import("../extension.js").ExtensionDescriptor<{
+    number: {
+        /**
+         * Validates that the number is strictly greater than zero.
+         *
+         * @param errorMessage - custom error message or function to generate one
+         * @returns a new schema builder with the positive validator applied
+         *
+         * @example
+         * ```ts
+         * number().positive();
+         * number().positive('Must be greater than zero');
+         * ```
+         */
+        positive(this: NumberSchemaBuilder, errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberSchemaBuilder<number, true, false, false, {}>;
+        /**
+         * Validates that the number is strictly less than zero.
+         *
+         * @param errorMessage - custom error message or function to generate one
+         * @returns a new schema builder with the negative validator applied
+         *
+         * @example
+         * ```ts
+         * number().negative();
+         * number().negative('Must be below zero');
+         * ```
+         */
+        negative(this: NumberSchemaBuilder, errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberSchemaBuilder<number, true, false, false, {}>;
+        /**
+         * Validates that the number is finite (rejects `Infinity` and `-Infinity`).
+         *
+         * @param errorMessage - custom error message or function to generate one
+         * @returns a new schema builder with the finite validator applied
+         *
+         * @example
+         * ```ts
+         * number().finite();
+         * number().finite('No infinities allowed');
+         * ```
+         */
+        finite(this: NumberSchemaBuilder, errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberSchemaBuilder<number, true, false, false, {}>;
+        /**
+         * Validates that the number is an exact multiple of `n`.
+         *
+         * Uses a relative tolerance of `1e-10` for float-safe comparison.
+         *
+         * @param n - the divisor to check against
+         * @param errorMessage - custom error message or function to generate one
+         * @returns a new schema builder with the multipleOf validator applied
+         *
+         * @example
+         * ```ts
+         * number().multipleOf(5);
+         * number().multipleOf(0.1, 'Must be a multiple of 0.1');
+         * ```
+         */
+        multipleOf(this: NumberSchemaBuilder, n: number, errorMessage?: ValidationErrorMessageProvider<NumberSchemaBuilder>): NumberSchemaBuilder<number, true, false, false, {}>;
+        /**
+         * Constrains the number to one of the specified literal values.
+         *
+         * @param args - the allowed number literals, optionally followed by an error message
+         * @returns a new schema builder restricted to the given values
+         *
+         * @example
+         * ```ts
+         * number().oneOf(1, 2, 3);
+         * number().oneOf([1, 2, 3], 'Must be 1, 2, or 3');
+         * ```
+         */
+        oneOf(this: NumberSchemaBuilder, ...args: any[]): NumberSchemaBuilder<number, true, false, false, {}>;
+    };
+}>;
+export {};