@cleverbrush/schema 0.0.0-beta-20260410073748

package/dist/builders/AnySchemaBuilder.d.ts

@@ -0,0 +1,116 @@
+import { type BRAND, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult } from './SchemaBuilder.js';
+type AnySchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnType<AnySchemaBuilder<R>['introspect']>>;
+/**
+ * Any schema builder class. Similar to the `any` type
+ * in TypeScript. Allows to define a schema for `any` value.
+ * Use it when you don't know the type of the 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 `any()` function instead.
+ *
+ * @example
+ * ```ts
+ * const schema = any();
+ * const result = schema.validate(123);
+ * // result.valid === true
+ * // result.object === 123
+ * ```
+ */
+export declare class AnySchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TExplicitType = undefined, THasDefault extends boolean = false, TExtensions = {}, TResult = TExplicitType extends undefined ? any : TExplicitType> extends SchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> {
+    #private;
+    /**
+     * @hidden
+     */
+    static create(props: AnySchemaBuilderCreateProps<any>): AnySchemaBuilder<true, false, undefined, false, {}, any>;
+    protected constructor(props: AnySchemaBuilderCreateProps<TRequired>);
+    /**
+     * @inheritdoc
+     */
+    hasType<T>(_notUsed?: T): AnySchemaBuilder<true, TNullable, T, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @inheritdoc
+     */
+    clearHasType(): AnySchemaBuilder<TRequired, TNullable, undefined, 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 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: AnySchemaBuilderCreateProps<TReq>): this;
+    /**
+     * @hidden
+     */
+    required(errorMessage?: ValidationErrorMessageProvider): AnySchemaBuilder<true, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): AnySchemaBuilder<false, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): AnySchemaBuilder<true, TNullable, TExplicitType, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): AnySchemaBuilder<TRequired, TNullable, TExplicitType, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): AnySchemaBuilder<TRequired, TNullable, TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `Readonly<T>`. Sets the `isReadonly`
+     * introspection flag for tooling consistency.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): AnySchemaBuilder<TRequired, TNullable, Readonly<TResult>, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): AnySchemaBuilder<TRequired, true, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): AnySchemaBuilder<TRequired, false, TExplicitType, THasDefault, TExtensions> & TExtensions;
+}
+/**
+ * Creates a `any` schema.
+ * @example
+ * ```
+ *  const anyObject = any();
+ *
+ * // null - invalid
+ * // undefined - invalid
+ * // string - valid
+ * // {} - valid
+ * // Date -valid
+ * // { someProp: 123 } - valid
+ * // etc
+ * ```
+ * @example
+ * ```
+ *  const anyObject = any().optional();
+ *  // null - valid
+ *  // undefined - valid
+ *  // string - valid
+ *  // {} - valid
+ *  // Date -valid
+ *  // { someProp: 123 } - valid
+ * ```
+ */
+export declare const any: () => AnySchemaBuilder<true>;
+export {};

package/dist/builders/AnySchemaBuilder.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-ZAN4ZHCJ.js";import"../chunk-CTP4RHDG.js";export{a as AnySchemaBuilder,b as any};
+//# sourceMappingURL=AnySchemaBuilder.js.map

package/dist/builders/AnySchemaBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/builders/ArraySchemaBuilder.d.ts

@@ -0,0 +1,214 @@
+import type { ObjectSchemaBuilder, ObjectSchemaValidationResult } from './ObjectSchemaBuilder.js';
+import { type BRAND, type InferType, type NestedValidationResult, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult } from './SchemaBuilder.js';
+import type { UnionSchemaBuilder, UnionSchemaValidationResult } from './UnionSchemaBuilder.js';
+/**
+ * Maps an element schema type to the appropriate validation result type.
+ * Union schema elements get `UnionSchemaValidationResult`,
+ * Object schema elements get `ObjectSchemaValidationResult`,
+ * other types get `ValidationResult`.
+ */
+export type ElementValidationResult<TElementSchema extends SchemaBuilder<any, any, any, any, any>> = TElementSchema extends UnionSchemaBuilder<infer UOptions extends readonly SchemaBuilder<any, any, any, any, any>[], any, any> ? UnionSchemaValidationResult<InferType<TElementSchema>, UOptions> : TElementSchema extends ObjectSchemaBuilder<any, any, any, any, any> ? ObjectSchemaValidationResult<InferType<TElementSchema>, TElementSchema> : ValidationResult<InferType<TElementSchema>>;
+/**
+ * Validation result type returned by `ArraySchemaBuilder.validate()`.
+ * Extends `ValidationResult` with `getNestedErrors` for root-level array
+ * errors and per-element validation results.
+ */
+export type ArraySchemaValidationResult<TResult, TElementSchema extends SchemaBuilder<any, any, any, any, any>> = ValidationResult<TResult> & {
+    /**
+     * Returns root-level array validation errors combined with
+     * per-element validation results.
+     * The returned value has both `NestedValidationResult` properties
+     * (`errors`, `isValid`, `descriptor`, `seenValue`) and indexed
+     * element results (`[0]`, `[1]`, etc.).
+     */
+    getNestedErrors(): Array<ElementValidationResult<TElementSchema>> & NestedValidationResult<any, any, any>;
+};
+type ArraySchemaBuilderCreateProps<TElementSchema extends SchemaBuilder<any, any, any, any, any>, R extends boolean = true> = Partial<ReturnType<ArraySchemaBuilder<TElementSchema, R>['introspect']>>;
+/**
+ * Similar to the `Array` type in TypeScript. It can be used to validate arrays of any type.
+ * It can also be used to validate arrays of specific type.
+ * For example, if you want to validate an array of numbers,
+ * you can use `array(number())` to create a schema builder.
+ * If you want to validate an array of users, you can use
+ * `array().of(object({ name: string(), age: number() }))` to create a schema builder.
+ * If you want to validate an array of numbers or strings,
+ * you can use `array(union(number()).or(string()))`.
+ *
+ * Also you can limit the length of the array by using `minLength`
+ * and `maxLength` methods.
+ *
+ * **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 array | array()} function instead.
+ * @see {@link array}
+ */
+export declare class ArraySchemaBuilder<TElementSchema extends SchemaBuilder<any, any, any, any, any>, TRequired extends boolean = true, TNullable extends boolean = false, TExplicitType = undefined, THasDefault extends boolean = false, TExtensions = {}, TResult = TExplicitType extends undefined ? TElementSchema extends undefined ? Array<any> : TElementSchema extends SchemaBuilder<infer T1, infer T2> ? Array<InferType<SchemaBuilder<T1, T2>>> : never : TExplicitType> extends SchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> {
+    #private;
+    /**
+     * @hidden
+     */
+    static create(props: ArraySchemaBuilderCreateProps<any, any>): ArraySchemaBuilder<SchemaBuilder<any, any, any, any, any>, true, false, undefined, false, {}, any[]>;
+    protected constructor(props: ArraySchemaBuilderCreateProps<TElementSchema, TRequired>);
+    /**
+     * @inheritdoc
+     */
+    hasType<T>(_notUsed?: T): ArraySchemaBuilder<TElementSchema, true, TNullable, T, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @inheritdoc
+     */
+    clearHasType(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, undefined, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Performs synchronous validation of the schema over `object`. {@inheritDoc SchemaBuilder.validate}
+     */
+    validate(object: TResult, context?: ValidationContext): ArraySchemaValidationResult<TResult, TElementSchema>;
+    /**
+     * Performs asynchronous validation of the schema over `object`. {@inheritDoc SchemaBuilder.validateAsync}
+     */
+    validateAsync(object: TResult, context?: ValidationContext): Promise<ArraySchemaValidationResult<TResult, TElementSchema>>;
+    /**
+     * 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): ArraySchemaValidationResult<TResult, TElementSchema>;
+    /**
+     * 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<ArraySchemaValidationResult<TResult, TElementSchema>>;
+    /**
+     * @hidden
+     */
+    protected createFromProps<TReq extends boolean>(props: ArraySchemaBuilderCreateProps<TElementSchema, TReq>): this;
+    /**
+     * @hidden
+     */
+    required(errorMessage?: ValidationErrorMessageProvider): ArraySchemaBuilder<TElementSchema, true, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): ArraySchemaBuilder<TElementSchema, false, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): ArraySchemaBuilder<TElementSchema, true, TNullable, TExplicitType, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `ReadonlyArray<T>` — disables `push`,
+     * `pop`, and other mutating methods at the type level. Validation
+     * behaviour is unchanged.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, ReadonlyArray<TElementSchema extends SchemaBuilder<infer T1, infer T2> ? InferType<SchemaBuilder<T1, T2>> : any>, THasDefault, TExtensions> & TExtensions;
+    introspect(): {
+        /**
+         * Schema of array item (if defined)
+         */
+        elementSchema: TElementSchema | undefined;
+        /**
+         * Min length of a valid array
+         */
+        minLength: number | undefined;
+        /**
+         * Min length validation error message provider.
+         * If not provided, default error message provider is used.
+         */
+        minLengthValidationErrorMessageProvider: ValidationErrorMessageProvider<ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, false, {}, TExplicitType extends undefined ? TElementSchema extends undefined ? any[] : TElementSchema extends SchemaBuilder<infer T1, infer T2 extends boolean, false, false, {}> ? (T2 extends true ? T1 : T1 | undefined)[] : never : TExplicitType>>;
+        /**
+         * Max length of a valid array
+         */
+        maxLength: number | undefined;
+        /**
+         * Max length validation error message provider.
+         * If not provided, default error message provider is used.
+         */
+        maxLengthValidationErrorMessageProvider: ValidationErrorMessageProvider<ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, false, {}, TExplicitType extends undefined ? TElementSchema extends undefined ? any[] : TElementSchema extends SchemaBuilder<infer T1, infer T2 extends boolean, false, false, {}> ? (T2 extends true ? T1 : T1 | undefined)[] : never : TExplicitType>>;
+        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;
+        hasCatch: boolean;
+        catchValue: TResult | (() => TResult) | undefined;
+    };
+    /**
+     * Set a schema that every array item has to satisfy. If it is not set,
+     * Item of any type is allowed.
+     * @param schema Schema that every array item has to satisfy
+     */
+    of<TSchema extends SchemaBuilder<any, any, any, any, any>>(schema: TSchema): ArraySchemaBuilder<TSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Clears the element schema set by `of()`. After this call,
+     * array items of any type will be accepted.
+     */
+    clearOf(): ArraySchemaBuilder<any, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Set minimal length of the valid array value for schema.
+     */
+    minLength<T extends number>(length: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType>>): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Clear minimal length of the valid array value for schema.
+     */
+    clearMinLength(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Set max length of the valid array value for schema.
+     */
+    maxLength<T extends number>(length: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType>>): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Clear max length of the valid array value for schema.
+     */
+    clearMaxLength(): ArraySchemaBuilder<TElementSchema, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): ArraySchemaBuilder<TElementSchema, TRequired, true, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): ArraySchemaBuilder<TElementSchema, TRequired, false, TExplicitType, THasDefault, TExtensions> & TExtensions;
+}
+/**
+ * Creates a `Array` schema.
+ *
+ * @example
+ * ```typescript
+ *  const schema = array().minLength(2).maxLength(5).of(string());
+ *  // [] - invalid
+ *  // ['a', 'b'] - valid
+ *  // ['a', 'b', 'c', 'd', 'e', 'f'] - invalid
+ *  // ['a', 'b', 'c', 'd', 'e'] - valid
+ *  // ['a', 'b', 'c', 'd', 1] - invalid
+ *  // ['a', 'b', null] - invalid
+ *  // null - invalid
+ *  // undefined - invalid
+ * ```
+ */
+export declare const array: <TElementSchema extends SchemaBuilder<any, any, any, any, any>>(elementSchema?: TElementSchema) => ArraySchemaBuilder<TElementSchema, true>;
+export {};

package/dist/builders/ArraySchemaBuilder.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-Z7QZ7IXT.js";import"../chunk-CTP4RHDG.js";export{a as ArraySchemaBuilder,b as array};
+//# sourceMappingURL=ArraySchemaBuilder.js.map

package/dist/builders/ArraySchemaBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/builders/BooleanSchemaBuilder.d.ts

@@ -0,0 +1,146 @@
+import { type BRAND, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult } from './SchemaBuilder.js';
+type BooleanSchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnType<BooleanSchemaBuilder<R>['introspect']>>;
+/**
+ * Similar to `boolean` type in TypeScript.
+ * Allows to define a schema for a boolean value. It can be required or optional.
+ * It can be restricted to be equal to a certain 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 boolean | boolean()} function instead.
+ *
+ * @example ```ts
+ * const schema = boolean().equals(true);
+ * const result = schema.validate(true);
+ * // result.valid === true
+ * // result.object === true
+ * ```
+ * @example ```ts
+ * const schema = boolean().equals(false);
+ * const result = schema.validate(true);
+ * // result.valid === false
+ * // result.errors[0].message === 'is expected to be equal to 'false''
+ * ```
+ * @example ```ts
+ * const schema = boolean().equals(true).optional();
+ * const result = schema.validate(undefined);
+ * // result.valid === true
+ * // result.object === undefined
+ * ```
+ *
+ * @see {@link boolean}
+ */
+export declare class BooleanSchemaBuilder<TResult = boolean, TRequired extends boolean = true, TNullable extends boolean = false, TExplicitType = undefined, THasDefault extends boolean = false, TExtensions = {}, TFinalResult = TExplicitType extends undefined ? TResult : TExplicitType> extends SchemaBuilder<TFinalResult, TRequired, TNullable, THasDefault, TExtensions> {
+    #private;
+    /**
+     * @hidden
+     */
+    static create(props: BooleanSchemaBuilderCreateProps<any>): BooleanSchemaBuilder<boolean, any, false, undefined, false, {}, boolean>;
+    protected constructor(props: BooleanSchemaBuilderCreateProps<TRequired>);
+    introspect(): {
+        /**
+         * If set, restrict object to be equal to a certain value.
+         */
+        equalsTo: boolean | undefined;
+        /**
+         * Equals to validation error message provider.
+         * If not provided, default error message will be used.
+         */
+        equalsToValidationErrorMessageProvider: ValidationErrorMessageProvider<BooleanSchemaBuilder<TResult, TRequired, false, undefined, false, {}, TResult>>;
+        type: string;
+        isRequired: boolean;
+        isNullable: boolean;
+        isReadonly: boolean;
+        preprocessors: readonly import("./SchemaBuilder.js").PreprocessorEntry<TFinalResult>[];
+        validators: readonly import("./SchemaBuilder.js").ValidatorEntry<TFinalResult>[];
+        requiredValidationErrorMessageProvider: ValidationErrorMessageProvider<SchemaBuilder<any, any, any, any, any>>;
+        extensions: {
+            [x: string]: unknown;
+        };
+        hasDefault: boolean;
+        defaultValue: TFinalResult | (() => TFinalResult) | undefined;
+        description: string | undefined;
+        hasCatch: boolean;
+        catchValue: TFinalResult | (() => TFinalResult) | undefined;
+    };
+    /**
+     * @inheritdoc
+     */
+    hasType<T>(_notUsed?: T): BooleanSchemaBuilder<TResult, true, TNullable, T, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @inheritdoc
+     */
+    clearHasType(): BooleanSchemaBuilder<TResult, TRequired, TNullable, undefined, 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 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: BooleanSchemaBuilderCreateProps<TReq>): this;
+    /**
+     * @hidden
+     */
+    required(errorMessage?: ValidationErrorMessageProvider): BooleanSchemaBuilder<TResult, true, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): BooleanSchemaBuilder<TResult, false, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TFinalResult | (() => TFinalResult)): BooleanSchemaBuilder<TResult, true, TNullable, TExplicitType, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): BooleanSchemaBuilder<TResult, TRequired, TNullable, TExplicitType, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): BooleanSchemaBuilder<TResult, TRequired, TNullable, TFinalResult & {
+        readonly [K in BRAND]: TBrand;
+    }, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `Readonly<boolean>`. Since booleans are
+     * already immutable this is an identity operation, but it sets the
+     * `isReadonly` introspection flag for tooling consistency.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): BooleanSchemaBuilder<TResult, TRequired, TNullable, Readonly<TFinalResult>, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Restricts object to be equal to `value`.
+     */
+    equals<T extends boolean>(value: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<BooleanSchemaBuilder<TResult, TRequired>>): BooleanSchemaBuilder<T, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Removes a `value` defined by `equals()` call.
+     */
+    clearEquals(): BooleanSchemaBuilder<boolean, TRequired, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): BooleanSchemaBuilder<TResult, TRequired, true, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): BooleanSchemaBuilder<TResult, TRequired, false, TExplicitType, THasDefault, TExtensions> & TExtensions;
+}
+/**
+ * Creates a `boolean` schema.
+ */
+export declare const boolean: () => BooleanSchemaBuilder<boolean, true>;
+export {};

package/dist/builders/BooleanSchemaBuilder.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-KFTO7TMB.js";import"../chunk-CTP4RHDG.js";export{a as BooleanSchemaBuilder,b as boolean};
+//# sourceMappingURL=BooleanSchemaBuilder.js.map

package/dist/builders/BooleanSchemaBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}