@cleverbrush/schema 0.0.0-beta-20260410073748

package/dist/builders/StringSchemaBuilder.d.ts

@@ -0,0 +1,291 @@
+import { type BRAND, type PreprocessorEntry, SchemaBuilder, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult, type ValidatorEntry } from './SchemaBuilder.js';
+type StringSchemaBuilderCreateProps<T = string, R extends boolean = true> = Partial<ReturnType<StringSchemaBuilder<T, R>['introspect']>>;
+/**
+ * Allows to define a schema for a string. It can be: required or optional,
+ * restricted to be equal to a certain value, restricted to have a certain
+ * length, restricted to start with a certain value, restricted to end with
+ * a certain value, restricted to match a certain regular expression.
+ *
+ * **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 string | string()} function instead.
+ *
+ * @example ```ts
+ * const schema = string().equals('hello');
+ * const result = schema.validate('hello');
+ * // result.valid === true
+ * // result.object === 'hello'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().equals('hello');
+ * const result = schema.validate('world');
+ * // result.valid === false
+ * // result.errors[0].message === "is expected to be equal to 'hello'"
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().minLength(5);
+ * const result = schema.validate('hello');
+ * // result.valid === true
+ * // result.object === 'hello'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().minLength(5);
+ * const result = schema.validate('hi');
+ * // result.valid === false
+ * // result.errors[0].message === 'is expected to have a length of at least 5'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().minLength(2).maxLength(5);
+ * const result = schema.validate('yes');
+ * // result.valid === true
+ * // result.object === 'yes'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string('no');
+ * const result = schema.validate('yes');
+ * // result.valid === false
+ * // result.errors[0].message === "is expected to be equal to 'no'"
+ * ```
+ *
+ * @see {@link string}
+ */
+export declare class StringSchemaBuilder<TResult = string, 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: StringSchemaBuilderCreateProps): StringSchemaBuilder<string, true, false, false, {}>;
+    protected constructor(props: StringSchemaBuilderCreateProps);
+    introspect(): {
+        /**
+         * Min length of the string (if defined).
+         */
+        minLength: number | undefined;
+        /**
+         * Min length validation error message provider.
+         * If not provided, default error message will be used.
+         */
+        minLengthValidationErrorMessageProvider: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired, false, false, {}>>;
+        /**
+         * Max length of the string (if defined).
+         */
+        maxLength: number | undefined;
+        /**
+         * Max length validation error message provider.
+         * If not provided, default error message will be used.
+         */
+        maxLengthValidationErrorMessageProvider: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired, false, false, {}>>;
+        /**
+         * If set, restrict object to be equal to a certain value.
+         */
+        equalsTo: string | undefined;
+        /**
+         * Equals validation error message provider.
+         * If not provided, default error message will be used.
+         */
+        equalsToValidationErrorMessageProvider: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired, false, false, {}>>;
+        /**
+         * If set, restrict string to start with a certain value.
+         */
+        startsWith: string | undefined;
+        /**
+         * Starts with validation error message provider.
+         * If not provided, default error message will be used.
+         */
+        startsWithValidationErrorMessageProvider: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired, false, false, {}>>;
+        /**
+         * If set, restrict string to end with a certain value.
+         */
+        endsWith: string | undefined;
+        /**
+         * Ends with validation error message provider.
+         * If not provided, default error message will be used.
+         */
+        endsWithValidationErrorMessageProvider: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired, false, false, {}>>;
+        /**
+         * If set, restrict string to match a certain regular expression.
+         */
+        matches: RegExp | undefined;
+        /**
+         * Matches validation error message provider.
+         * If not provided, default error message will be used.
+         */
+        matchesValidationErrorMessageProvider: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired, false, false, {}>>;
+        /**
+         * Array of preprocessor functions
+         */
+        preprocessors: PreprocessorEntry<TResult>[];
+        /**
+         * Array of validator functions
+         */
+        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;
+        hasCatch: boolean;
+        catchValue: TResult | (() => TResult) | undefined;
+    };
+    /**
+     * @inheritdoc
+     */
+    hasType<T>(_notUsed?: T): StringSchemaBuilder<T, true, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @inheritdoc
+     */
+    clearHasType(): StringSchemaBuilder<string, 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 synchronous validation of string 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 string 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: StringSchemaBuilderCreateProps<T, TReq>): this;
+    /**
+     * Restricts string to be equal to `value`.
+     */
+    equals<T extends string>(value: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired>>): StringSchemaBuilder<T, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Cancels `equals()` call.
+     */
+    clearEquals(): StringSchemaBuilder<string, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): StringSchemaBuilder<TResult, TRequired, true, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): StringSchemaBuilder<TResult, TRequired, false, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    required(errorMessage?: ValidationErrorMessageProvider): StringSchemaBuilder<TResult, true, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): StringSchemaBuilder<TResult, false, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): StringSchemaBuilder<TResult, true, TNullable, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): StringSchemaBuilder<TResult, TRequired, TNullable, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): StringSchemaBuilder<TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `Readonly<string>`. Since strings are
+     * already immutable this is an identity operation, but it sets the
+     * `isReadonly` introspection flag for tooling consistency.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): StringSchemaBuilder<Readonly<TResult>, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Set minimal length of the valid value for schema.
+     * @param length minimum string length
+     */
+    minLength(length: number, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired>>): StringSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Cancel `minLength()` call.
+     */
+    clearMinLength(): StringSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Set maximal length of the valid value for schema.
+     * @param length maximum string length
+     */
+    maxLength(length: number, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired>>): StringSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Cancel `maxLength()` call.
+     */
+    clearMaxLength(): StringSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Restricts string to start with `val`.
+     */
+    startsWith<T extends string>(val: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired>>): StringSchemaBuilder<TResult extends string ? `${T}${TResult}` : TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Cancels `startsWith()` call.
+     */
+    clearStartsWith(): StringSchemaBuilder<string, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Restricts string to end with `val`.
+     */
+    endsWith<T extends string>(val: T, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired>>): StringSchemaBuilder<TResult extends string ? `${TResult}${T}` : TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Cancels `endsWith()` call.
+     */
+    clearEndsWith(): StringSchemaBuilder<string, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Restricts string to match `regexp`.
+     * @param regexp regular expression pattern to match against
+     */
+    matches(regexp: RegExp, 
+    /**
+     * Custom error message provider.
+     */
+    errorMessage?: ValidationErrorMessageProvider<StringSchemaBuilder<TResult, TRequired>>): StringSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Cancels `matches()` call.
+     */
+    clearMatches(): StringSchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> & TExtensions;
+}
+/**
+ * Creates a string schema restricted to be equal to `equals`.
+ * @param equals string value the schema is restricted to
+ */
+export declare function string<T extends string>(equals: T): StringSchemaBuilder<T, true>;
+/**
+ * Creates a string schema restricted to be equal to `equals` with a custom error message.
+ * @param equals string value the schema is restricted to
+ */
+export declare function string<T extends string>(equals: T, errorMessage: ValidationErrorMessageProvider<StringSchemaBuilder<T, true>>): StringSchemaBuilder<T, true>;
+export declare function string(): StringSchemaBuilder<string, true>;
+export {};

package/dist/builders/StringSchemaBuilder.js

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

package/dist/builders/StringSchemaBuilder.js.map

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

package/dist/builders/TupleSchemaBuilder.d.ts

@@ -0,0 +1,248 @@
+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 a tuple of schema builders to a tuple of their per-position
+ * validation result types.
+ * Union schema elements get `UnionSchemaValidationResult`,
+ * object schema elements get `ObjectSchemaValidationResult`,
+ * other types get `ValidationResult`.
+ */
+export type TupleElementValidationResults<TElements extends readonly SchemaBuilder<any, any, any, any, any>[]> = {
+    [K in keyof TElements]: TElements[K] extends UnionSchemaBuilder<infer UOptions extends readonly SchemaBuilder<any, any, any, any, any>[], any, any> ? UnionSchemaValidationResult<InferType<TElements[K]>, UOptions> : TElements[K] extends ObjectSchemaBuilder<any, any, any, any, any> ? ObjectSchemaValidationResult<InferType<TElements[K]>, TElements[K]> : ValidationResult<InferType<TElements[K]>>;
+};
+/**
+ * Validation result type returned by `TupleSchemaBuilder.validate()`.
+ * Extends `ValidationResult` with `getNestedErrors` for root-level tuple
+ * errors and per-position validation results.
+ */
+export type TupleSchemaValidationResult<TResult, TElements extends readonly SchemaBuilder<any, any, any, any, any>[]> = ValidationResult<TResult> & {
+    /**
+     * Returns root-level tuple validation errors combined with
+     * per-position validation results.
+     * The returned value has both `NestedValidationResult` properties
+     * (`errors`, `isValid`, `descriptor`, `seenValue`) and indexed
+     * position results (`[0]`, `[1]`, etc.).
+     */
+    getNestedErrors(): TupleElementValidationResults<TElements> & NestedValidationResult<any, any, any>;
+};
+type TupleSchemaBuilderCreateProps<TElements extends readonly SchemaBuilder<any, any, any, any, any>[], TRestSchema extends SchemaBuilder<any, any, any, any, any> | undefined = undefined, R extends boolean = true, N extends boolean = false> = Partial<ReturnType<TupleSchemaBuilder<TElements, R, N, undefined, false, {}, TRestSchema>['introspect']>>;
+/**
+ * Fixed-length array schema builder with per-position type validation.
+ * Similar to TypeScript's tuple types — each element at a specific array index
+ * is validated against its own schema.
+ *
+ * Use it when you need to validate function arguments, CSV rows, coordinate
+ * pairs, structured event payloads, or any other fixed-structure array.
+ *
+ * **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 tuple | tuple()} function instead.
+ *
+ * @example
+ * ```ts
+ * const schema = tuple([string(), number(), boolean()]);
+ * // Inferred TypeScript type: [string, number, boolean]
+ *
+ * schema.validate(['hello', 42, true]);
+ * // result.valid === true
+ * // result.object === ['hello', 42, true]
+ *
+ * schema.validate(['hello', 42]);
+ * // result.valid === false  (too few elements)
+ *
+ * schema.validate(['hello', 'oops', true]);
+ * // result.valid === false  (wrong type at position 1)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Tuple with variadic rest elements
+ * const schema = tuple([string(), number()]).rest(boolean());
+ * // Inferred TypeScript type: [string, number, ...boolean[]]
+ *
+ * schema.validate(['hello', 42, true, false]);
+ * // result.valid === true — any number of extra booleans allowed
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Nested tuple combining with object schemas
+ * const point = tuple([number(), number()]);
+ * const segment = tuple([point, point]);
+ *
+ * segment.validate([[0, 0], [10, 20]]);
+ * // result.valid === true
+ * ```
+ *
+ * @see {@link tuple}
+ */
+export declare class TupleSchemaBuilder<TElements extends readonly SchemaBuilder<any, any, any, any, any>[], TRequired extends boolean = true, TNullable extends boolean = false, TExplicitType = undefined, THasDefault extends boolean = false, TExtensions = {}, TRestSchema extends SchemaBuilder<any, any, any, any, any> | undefined = undefined, TResult = TExplicitType extends undefined ? TRestSchema extends SchemaBuilder<any, any, any, any, any> ? [
+    ...{
+        [K in keyof TElements]: InferType<TElements[K]>;
+    },
+    ...Array<InferType<TRestSchema>>
+] : {
+    [K in keyof TElements]: InferType<TElements[K]>;
+} : TExplicitType> extends SchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> {
+    #private;
+    /**
+     * @hidden
+     */
+    static create(props: TupleSchemaBuilderCreateProps<any, any, any, any>): TupleSchemaBuilder<readonly SchemaBuilder<any, any, any, any, any>[], true, false, undefined, false, {}, undefined, readonly any[]>;
+    protected constructor(props: TupleSchemaBuilderCreateProps<TElements, TRestSchema, TRequired, TNullable>);
+    /**
+     * @inheritdoc
+     */
+    hasType<T>(_notUsed?: T): TupleSchemaBuilder<TElements, true, TNullable, T, THasDefault, TExtensions, TRestSchema> & TExtensions;
+    /**
+     * @inheritdoc
+     */
+    clearHasType(): TupleSchemaBuilder<TElements, TRequired, TNullable, undefined, THasDefault, TExtensions, TRestSchema> & TExtensions;
+    /**
+     * Performs synchronous validation of the schema over `object`. {@inheritDoc SchemaBuilder.validate}
+     */
+    validate(object: TResult, context?: ValidationContext): TupleSchemaValidationResult<TResult, TElements>;
+    /**
+     * Performs asynchronous validation of the schema over `object`. {@inheritDoc SchemaBuilder.validateAsync}
+     */
+    validateAsync(object: TResult, context?: ValidationContext): Promise<TupleSchemaValidationResult<TResult, TElements>>;
+    /**
+     * 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): TupleSchemaValidationResult<TResult, TElements>;
+    /**
+     * 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<TupleSchemaValidationResult<TResult, TElements>>;
+    /**
+     * @hidden
+     */
+    protected createFromProps<TReq extends boolean>(props: TupleSchemaBuilderCreateProps<TElements, TRestSchema, TReq>): this;
+    /**
+     * @hidden
+     */
+    required(errorMessage?: ValidationErrorMessageProvider): TupleSchemaBuilder<TElements, true, TNullable, TExplicitType, THasDefault, TExtensions, TRestSchema> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): TupleSchemaBuilder<TElements, false, TNullable, TExplicitType, THasDefault, TExtensions, TRestSchema> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): TupleSchemaBuilder<TElements, true, TNullable, TExplicitType, true, TExtensions, TRestSchema> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): TupleSchemaBuilder<TElements, TRequired, TNullable, TExplicitType, false, TExtensions, TRestSchema> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): TupleSchemaBuilder<TElements, TRequired, TNullable, TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, THasDefault, TExtensions, TRestSchema> & TExtensions;
+    introspect(): {
+        /**
+         * Per-position element schemas defining the fixed tuple structure.
+         */
+        elements: TElements;
+        /**
+         * Optional schema for elements beyond the fixed positions.
+         * When set, additional elements are validated against this schema.
+         * Mirrors TypeScript's rest element syntax: `[string, number, ...boolean[]]`.
+         */
+        restSchema: (TRestSchema & SchemaBuilder<any, any, any, any, any>) | undefined;
+        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;
+    };
+    /**
+     * Sets a schema that all elements beyond the fixed positions must satisfy.
+     * Mirrors TypeScript's variadic tuple tail: `[string, number, ...boolean[]]`.
+     *
+     * When set, the tuple length must be at least equal to the number of fixed
+     * elements, and any additional elements are validated against `schema`.
+     * When not set, the tuple length must be exactly equal to the fixed count.
+     *
+     * @param schema Schema that extra array elements must satisfy.
+     *
+     * @example
+     * ```ts
+     * const schema = tuple([string(), number()]).rest(boolean());
+     * // Inferred TypeScript type: [string, number, ...boolean[]]
+     *
+     * schema.validate(['hello', 42]);               // valid
+     * schema.validate(['hello', 42, true]);          // valid
+     * schema.validate(['hello', 42, true, false]);   // valid
+     * schema.validate(['hello', 42, 'extra']);       // invalid — 'extra' not boolean
+     * ```
+     */
+    rest<TSchema extends SchemaBuilder<any, any, any, any, any>>(schema: TSchema): TupleSchemaBuilder<TElements, TRequired, TNullable, TExplicitType, THasDefault, TExtensions, TSchema> & TExtensions;
+    /**
+     * Removes the rest schema set by `rest()`. After this call, the tuple
+     * length must be exactly equal to the number of fixed element schemas.
+     */
+    clearRest(): TupleSchemaBuilder<TElements, TRequired, TNullable, TExplicitType, THasDefault, TExtensions, undefined> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): TupleSchemaBuilder<TElements, TRequired, true, TExplicitType, THasDefault, TExtensions, TRestSchema> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): TupleSchemaBuilder<TElements, TRequired, false, TExplicitType, THasDefault, TExtensions, TRestSchema> & TExtensions;
+}
+/**
+ * Creates a fixed-length array schema (tuple) where each element at a
+ * specific index is validated against its own schema.
+ *
+ * @param elements Array of per-position schemas. The length of this array
+ *   determines the required tuple length (unless `.rest()` is used).
+ *
+ * @example
+ * ```ts
+ * import { tuple, string, number, boolean } from '@cleverbrush/schema';
+ *
+ * const schema = tuple([string(), number(), boolean()]);
+ * // Inferred TypeScript type: [string, number, boolean]
+ *
+ * schema.validate(['hello', 42, true]);     // valid
+ * schema.validate(['hello', 42]);           // invalid — too few elements
+ * schema.validate(['hello', 'oops', true]); // invalid — wrong type at [1]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // 2-D coordinate pair
+ * const point = tuple([number(), number()]);
+ * const result = point.validate([10.5, 20.3]);
+ * // result.valid === true
+ * // result.object === [10.5, 20.3]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Optional tuple with default value
+ * const schema = tuple([string(), number()])
+ *     .optional()
+ *     .default(() => ['', 0]);
+ * ```
+ */
+export declare const tuple: <const TElements extends readonly SchemaBuilder<any, any, any, any, any>[]>(elements: [...TElements]) => TupleSchemaBuilder<TElements, true>;
+export {};

package/dist/builders/TupleSchemaBuilder.js

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

package/dist/builders/TupleSchemaBuilder.js.map

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