@maroonedog/luq 0.1.0-alpha

package/dist/constants.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Essential constants - optimized for minimal bundle size
+ * Only contains constants that are actively used in the codebase
+ */
+export declare const DOT = ".";
+export declare const VALIDATE_MODE: "validate";
+export declare const PARSE_MODE: "parse";
+export type ValidationMode = typeof VALIDATE_MODE | typeof PARSE_MODE;
+/**
+ * Base message parameters for validation errors
+ */
+export interface BaseMessageParams {
+    path: string;
+    value?: any;
+}
+/**
+ * Extended message parameters with validation-specific properties
+ */
+export interface ValidationMessageParams extends BaseMessageParams {
+    expected?: any;
+    actual?: any;
+    min?: number;
+    max?: number;
+    pattern?: string;
+    code?: string;
+    [key: string]: any;
+}

package/dist/core/async.experimental/async-context.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Async Context Design - Separate async layer from validation
+ *
+ * User proposal: validator.withAsyncContext(ctx).validate()
+ * Completely decouple async layer from validation flow to maintain performance
+ */
+import { ValidationOptions, AsyncContextOptions, AsyncContext, AsyncAwareValidator } from "../builder/types/types";
+import { Result } from "../../types/result";
+/**
+ * Extended validation options for async context
+ */
+interface AsyncValidationOptions extends ValidationOptions {
+    asyncContext?: any;
+}
+/**
+ * Async context builder (simplified)
+ */
+export declare class AsyncContextBuilder<T = {}> {
+    private promises;
+    private options;
+    /**
+     * Add async data
+     */
+    set<K extends string, V>(key: K, promise: Promise<V>): AsyncContextBuilder<T & {
+        [P in K]: V;
+    }>;
+    /**
+     * Set options
+     */
+    withOptions(options: AsyncContextOptions): this;
+    /**
+     * Build async context (simplified)
+     */
+    build(): Promise<AsyncContext<T>>;
+}
+/**
+ * Helper to create async context
+ */
+export declare function createAsyncContext<T = {}>(): AsyncContextBuilder<T>;
+/**
+ * Decorator to add async functionality to existing validator (type-safe version)
+ */
+export declare function addAsyncSupport<TObject>(validator: {
+    validate: (value: any, options?: any) => Result<TObject>;
+}): AsyncAwareValidator<TObject>;
+/**
+ * Helper to access async context in plugins (type-safe version)
+ */
+export declare function getAsyncContext<T extends Record<string, any> = Record<string, any>>(options?: AsyncValidationOptions): T | undefined;
+/**
+ * Type-safe async context access (with key)
+ */
+export declare function getAsyncContextValue<T extends Record<string, any>, K extends keyof T>(options: ValidationOptions | undefined, key: K): T[K] | undefined;
+/**
+ * Type guard for async context
+ */
+export declare function hasAsyncContextKey<T extends Record<string, any>, K extends keyof T>(options: ValidationOptions | undefined, key: K): options is ValidationOptions & {
+    asyncContext: T;
+};
+export {};

package/dist/core/builder/array-batch-optimizer.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Array Batch Processing Optimizer
+ *
+ * Optimizes validation by batching array element fields:
+ * Instead of accessing the same array multiple times for different element properties,
+ * we access the array once and validate all element properties in batch.
+ *
+ * Example:
+ * - customer.addresses.type
+ * - customer.addresses.name
+ * - customer.addresses.street
+ *
+ * Instead of 3 separate array accesses, we do:
+ * 1. Get customer.addresses array once
+ * 2. For each address element, validate type, name, street together
+ */
+import { ValidationMode } from "../../constants";
+import { ArrayStructureInfo } from "../../types/array-type-analysis";
+import { NestedArrayBatchInfo } from "./nested-array-processor";
+export interface ArrayBatchInfo {
+    arrayPath: string;
+    elementFields: string[];
+    fullFieldPaths: string[];
+    validators: Map<string, any>;
+    accessors: Map<string, (obj: any) => any>;
+    arrayStructure?: ArrayStructureInfo;
+    optimizedValidator?: (array: any, rootData: any, options: any) => ValidationResult;
+    _nestedInfo?: NestedArrayBatchInfo;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: Array<{
+        path: string;
+        code: string;
+        message: string;
+        paths: () => string[];
+    }>;
+    transformedData?: any;
+}
+/**
+ * Field definition with array information
+ */
+interface FieldDefinitionWithArray {
+    path: string;
+    builderFunction?: (context: any) => any;
+    inferredType?: string;
+    isArrayField?: boolean;
+}
+/**
+ * Analyze field paths to identify array batching opportunities
+ * Now uses field definitions with array field information
+ */
+export declare function analyzeArrayBatching(fieldDefinitions: FieldDefinitionWithArray[]): Map<string, ArrayBatchInfo>;
+/**
+ * Create optimized batch validator for array processing
+ */
+export declare function createArrayBatchValidator(batchInfo: ArrayBatchInfo, fieldValidators: Map<string, any>): (arrayData: any[], rootData: any, abortEarly: boolean, abortEarlyOnEachField: boolean, mode?: ValidationMode) => {
+    errors: Array<{
+        path: string;
+        code: string;
+        message: string;
+        paths: () => string[];
+    }>;
+    transformedData?: any[];
+};
+export {};

package/dist/core/builder/context/field-context.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Optimized field context creation for V8 performance
+ * Removes Proxy usage and reduces object allocation
+ */
+import type { TypeName, ChainableFieldBuilder, FieldBuilderContext, TransformFunction } from "../plugins/plugin-types";
+type OptimizedValidator<T = unknown> = (value: T, currentValue: T) => boolean;
+interface ValidatorWithMeta<TValue = unknown> {
+    check: OptimizedValidator<TValue>;
+    name: string;
+    messageFactory?: (context: any) => string;
+    inputType?: TypeName;
+    outputType?: TypeName;
+    metadata?: {
+        severity?: "error" | "warning" | "info";
+        async?: boolean;
+        dependencies?: string[];
+    };
+}
+/**
+ * Create type-safe chainable field builder without Proxy
+ * All methods are directly attached to the builder object with proper typing
+ */
+export declare function createOptimizedTypeBuilder<TObject extends object, TPlugins, TType extends TypeName>(type: TType, fieldPath: string, plugins: TPlugins, existingState?: {
+    validators: ValidatorWithMeta<unknown>[];
+    transforms: Array<TransformFunction<unknown, unknown>>;
+}): ChainableFieldBuilder<TObject, TPlugins, TType, any>;
+/**
+ * Create type-safe field context without Proxy
+ */
+export declare function createOptimizedFieldContext<TObject extends object, TPlugins, TFieldType>(fieldPath: string, plugins: TPlugins): FieldBuilderContext<TObject, TPlugins, TFieldType>;
+export { createOptimizedFieldContext as createFieldContext };

package/dist/core/builder/context/field-type-detector.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Field Type Detector
+ * Detects the actual type of a field by tracking which type builder is used
+ */
+export type FieldType = "string" | "number" | "boolean" | "date" | "array" | "object" | "tuple" | "union";
+/**
+ * Detect field type by executing the builder function and tracking which type builder is accessed
+ */
+export declare function detectFieldType(fieldDef: {
+    path: string;
+    builderFunction: Function;
+}, plugins: Record<string, any>): FieldType | null;
+/**
+ * Batch detect field types for multiple field definitions
+ */
+export declare function detectFieldTypes(fieldDefinitions: Array<{
+    path: string;
+    builderFunction: Function;
+}>, plugins: Record<string, any>): Map<string, FieldType>;

package/dist/core/builder/core/builder.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Enhanced integration with better type inference
+ */
+import { IChainableBuilder } from "../types/types";
+export type { ChainableBuilder, IChainableBuilder, PluginMapFromArray, BuilderExtensions, } from "../types/types";
+/**
+ * Factory function with better type inference
+ */
+declare function createBuilder<TInput = any>(): IChainableBuilder<TInput, {}, {}>;
+export declare const Builder: typeof createBuilder;

package/dist/core/builder/core/field-builder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Refactored Field Builder - Streamlined through separation of concerns
+ * Focused on core builder logic
+ */
+import type { FieldBuilder } from "../plugins/plugin-types";
+import { FieldBuilderDefinition } from "../types/types";
+export type { FieldBuilder } from "../plugins/plugin-types";
+export type { FieldBuilderDefinition } from "../types/types";
+/**
+ * Streamlined FieldBuilder implementation focused on core building logic
+ */
+export declare function createFieldBuilderImpl<TObject extends object, TMap = {}, TPlugins = {}, TDeclaredFields extends string = never>(plugins: TPlugins, chainableBuilder: any, fieldDefinitions?: Array<FieldBuilderDefinition>, isStrict?: boolean): FieldBuilder<TObject, TMap, TPlugins, TDeclaredFields>;
+export declare const FieldBuilderImpl: any;

package/dist/core/builder/core/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Builder module exports
+ *
+ * This module contains all the core functionality for creating and managing plugins
+ */
+export { Builder } from "./builder";
+export { PluginValidationResult as BasicValidationResult, StandardPluginImplementation, ConditionalPluginImplementation, TransformPluginImplementation, FieldReferencePluginImplementation, ArrayElementPluginImplementation, } from "../plugins/plugin-interfaces";
+export { plugin, PluginImplementation, pluginPredefinedTransform, pluginConfigurableTransform, } from "../plugins/plugin-creator";
+export * from "../plugins/plugin-types";
+export { FieldBuilder, createFieldBuilderImpl } from "./field-builder";
+export { createFieldContext, createOptimizedFieldContext, } from "../context/field-context";
+export { createComposablePlugin, attachComposablePlugin, createValidator, createValidatorResult, createSingleValidatorResult, createCompositionBuilder, mergeValidatorResults, VALID_RESULT, INVALID_RESULT, } from "../plugins/composable-plugin";
+export type { ComposablePlugin, ComposableValidatorResult, ValidatorDefinition, TransformFunction, CompositionBuilder, } from "../plugins/composable-plugin";
+export { createComposableConditionalPlugin } from "../plugins/composable-conditional-plugin";
+export type { ComposableConditionalPlugin } from "../plugins/composable-conditional-plugin";
+export { createComposableDirectlyPlugin } from "../plugins/composable-directly-plugin";
+export type { ComposableDirectlyPlugin } from "../plugins/composable-directly-plugin";

package/dist/core/builder/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Builder module - organized by functionality
+ *
+ * New directory structure:
+ * - core/         - Core builder functionality
+ * - plugins/      - Plugin system
+ * - context/      - Field context management
+ * - validation/   - Validation engine
+ * - types/        - Type definitions and results
+ * - analysis/     - Analysis and optimization
+ */
+export * from "./core/builder";
+export * from "./core/field-builder";
+export * from "./plugins/composable-plugin";
+export * from "./plugins/composable-conditional-plugin";
+export * from "./plugins/composable-directly-plugin";
+export * from "./plugins/plugin-interfaces";
+export * from "./plugins/plugin-types";
+export * from "./context/field-context";
+export { createValidatorFactory } from "./validator-factory";
+export * from "./types/types";
+export { Builder } from "./core/builder";
+export type { FieldBuilder } from "./core/field-builder";
+export { createFieldContext } from "./context/field-context";

package/dist/core/builder/nested-array-processor.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Enhanced Nested Array Processor
+ *
+ * Supports complete nested array validation with accurate error paths.
+ * This module handles arrays at any depth level with proper index tracking.
+ */
+import { ValidationMode } from "../../constants";
+/**
+ * Parse array element path pattern and extract array path and element field
+ * Examples:
+ * - "items[*].name" => { arrayPath: "items", elementField: "name" }
+ * - "items.*.name" => { arrayPath: "items", elementField: "name" }
+ * - "users[*].addresses[*].street" => { arrayPath: "users", elementField: "addresses[*].street" }
+ */
+export declare function parseArrayElementPath(path: string): {
+    isArrayElementPath: boolean;
+    arrayPath?: string;
+    elementField?: string;
+};
+export interface NestedArrayBatchInfo {
+    arrayPath: string;
+    elementFields: string[];
+    fullFieldPaths: string[];
+    validators: Map<string, any>;
+    accessors: Map<string, (obj: any) => any>;
+    childArrays: Map<string, NestedArrayBatchInfo>;
+    depth: number;
+    parentPath?: string;
+}
+/**
+ * Build hierarchical array structure from field definitions
+ */
+export declare function buildNestedArrayHierarchy(fieldDefinitions: Array<{
+    path: string;
+    isArrayField?: boolean;
+    builderFunction?: (context: any) => any;
+}>): Map<string, NestedArrayBatchInfo>;
+/**
+ * Create hierarchical nested array validator
+ */
+export declare function createNestedArrayValidator(nestedBatchInfo: NestedArrayBatchInfo, fieldValidators: Map<string, any>): (arrayData: any[], rootData: any, abortEarly: boolean, abortEarlyOnEachField: boolean, mode: ValidationMode, parentPath?: string) => NestedValidationResult;
+interface NestedError {
+    path: string;
+    code: string;
+    message: string;
+    paths: () => string[];
+}
+interface NestedValidationResult {
+    errors: NestedError[];
+    transformedData?: any[];
+}
+export {};

package/dist/core/builder/plugins/composable-conditional-plugin.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Composable Conditional Plugin Pattern - For guard-like conditional validation
+ *
+ * This module provides utilities for creating composable plugins that apply
+ * conditional validation based on type guards or conditions. This is specifically
+ * designed for union type validation where different rules apply based on the value type.
+ */
+import type { TypeName } from "../plugins/plugin-types";
+import { type ComposableValidatorResult } from "../plugins/composable-plugin";
+/**
+ * Interface for Composable Conditional Plugin
+ */
+export interface ComposableConditionalPlugin<TName extends string, TMethodName extends string, TAllowedTypes extends readonly TypeName[]> {
+    name: TName;
+    methodName: TMethodName;
+    allowedTypes: TAllowedTypes;
+    category: "composable-conditional";
+    /**
+     * Create a Composer that accumulates conditional validations
+     */
+    createComposer<TPlugins>(fieldPath: string, plugins: TPlugins): any;
+}
+/**
+ * Creates a composable conditional plugin for guard-based validation
+ *
+ * @param name - The unique name of the plugin
+ * @param methodName - The method name that will be added to the field builder
+ * @param allowedTypes - Array of type names this plugin can be applied to
+ * @param builderFn - Function that builds validators from accumulated conditions
+ * @returns A composable conditional plugin instance
+ */
+export declare function createComposableConditionalPlugin<TName extends string, TMethodName extends string, TAllowedTypes extends readonly TypeName[], TComposition = unknown[]>(name: TName, methodName: TMethodName, allowedTypes: TAllowedTypes, builderFn: <TPlugins>(compositions: TComposition[], fieldPath: string, plugins: TPlugins) => ComposableValidatorResult): ComposableConditionalPlugin<TName, TMethodName, TAllowedTypes>;

package/dist/core/builder/plugins/composable-directly-plugin.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Composable Directly Plugin Pattern - For direct builder composition
+ *
+ * This module provides utilities for creating composable plugins that directly
+ * compose builders without conditional logic. This is specifically designed for
+ * tuple validation where each element has its own builder.
+ */
+import type { TypeName } from "../plugins/plugin-types";
+import { type ComposableValidatorResult } from "../plugins/composable-plugin";
+/**
+ * Interface for Composable Directly Plugin
+ */
+export interface ComposableDirectlyPlugin<TName extends string, TMethodName extends string, TAllowedTypes extends readonly TypeName[]> {
+    name: TName;
+    methodName: TMethodName;
+    allowedTypes: TAllowedTypes;
+    category: "composable-directly";
+    /**
+     * Create a Composer that directly builds validators
+     */
+    createComposer<TPlugins>(fieldPath: string, plugins: TPlugins): any;
+}
+/**
+ * Creates a composable directly plugin for direct builder composition
+ *
+ * @param name - The unique name of the plugin
+ * @param methodName - The method name that will be added to the field builder
+ * @param allowedTypes - Array of type names this plugin can be applied to
+ * @param builderFn - Function that builds validators from composed builders
+ * @returns A composable directly plugin instance
+ */
+export declare function createComposableDirectlyPlugin<TName extends string, TMethodName extends string, TAllowedTypes extends readonly TypeName[], TComposition = unknown[]>(name: TName, methodName: TMethodName, allowedTypes: TAllowedTypes, builderFn: <TPlugins>(compositions: TComposition[], fieldPath: string, plugins: TPlugins) => ComposableValidatorResult): ComposableDirectlyPlugin<TName, TMethodName, TAllowedTypes>;

package/dist/core/builder/plugins/composable-plugin.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Composable Plugin Pattern - Accumulate multiple calls and build validators
+ *
+ * This module provides utilities for creating composable plugins that can accumulate
+ * multiple method calls and build a unified validator. This pattern is useful for
+ * validation rules that need to be composed from multiple conditions or checks.
+ *
+ * Example usage:
+ * ```typescript
+ * // Create a composable plugin
+ * const myPlugin = createComposablePlugin(
+ *   "myPlugin",
+ *   "check",
+ *   ["string", "number"] as const,
+ *   (compositions, fieldPath, plugins) => {
+ *     // Build validators from compositions
+ *     const validators = compositions.map(([arg1, arg2]) =>
+ *       createValidator("myCheck", (value) => checkSomething(value, arg1, arg2))
+ *     );
+ *     return createValidatorResult(validators);
+ *   }
+ * );
+ *
+ * // Use in field builder
+ * builder.field("name", b => b.string.check(arg1, arg2).check(arg3, arg4))
+ * ```
+ */
+import type { TypeName, TransformFunction } from "../plugins/plugin-types";
+export type { TransformFunction };
+/**
+ * Pre-defined validation results for common cases
+ */
+export declare const VALID_RESULT: Readonly<{
+    valid: true;
+}>;
+export declare const INVALID_RESULT: Readonly<{
+    valid: false;
+}>;
+/**
+ * Basic interface for Composable Plugin
+ */
+export interface ComposablePlugin<TName extends string, TMethodName extends string, TAllowedTypes extends readonly TypeName[]> {
+    name: TName;
+    methodName: TMethodName;
+    allowedTypes: TAllowedTypes;
+    category: "composable";
+    /**
+     * Create a Composer that accumulates multiple calls
+     */
+    createComposer<TPlugins>(fieldPath: string, plugins: TPlugins): ComposableComposerWithMethod<TMethodName>;
+}
+/**
+ * Single validator definition
+ */
+export interface ValidatorDefinition {
+    check: (value: unknown, currentValue: unknown) => boolean;
+    name: string;
+    inputType?: TypeName;
+    outputType?: TypeName;
+    metadata?: {
+        severity?: "error" | "warning" | "info";
+        async?: boolean;
+    };
+}
+/**
+ * Validator build result type
+ */
+export interface ComposableValidatorResult {
+    _validators: ValidatorDefinition[];
+    _transforms: TransformFunction<unknown, unknown>[];
+    validate: (value: unknown) => {
+        valid: boolean;
+    };
+}
+/**
+ * Creates a validator result from an array of validators and transforms.
+ *
+ * @param validators - Array of validator definitions to include
+ * @param transforms - Optional array of transform functions to apply
+ * @param customValidate - Optional custom validation function that overrides default behavior
+ * @returns A composable validator result that can be used by the builder
+ *
+ * @example
+ * ```typescript
+ * const result = createValidatorResult([
+ *   createValidator("minLength", (value) => value.length >= 3),
+ *   createValidator("maxLength", (value) => value.length <= 10)
+ * ]);
+ * ```
+ */
+export declare function createValidatorResult(validators: ValidatorDefinition[], transforms?: TransformFunction<unknown, unknown>[], customValidate?: (value: unknown) => {
+    valid: boolean;
+}): ComposableValidatorResult;
+/**
+ * Creates a validator result from a single validator with optional configuration.
+ * This is a convenience function that combines createValidator and createValidatorResult.
+ *
+ * @param name - The name of the validator
+ * @param check - The validation function
+ * @param options - Optional configuration including metadata and transforms
+ * @returns A composable validator result
+ *
+ * @example
+ * ```typescript
+ * const result = createSingleValidatorResult(
+ *   "email",
+ *   (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
+ *   { inputType: "string", severity: "error" }
+ * );
+ * ```
+ */
+export declare function createSingleValidatorResult(name: string, check: (value: unknown, currentValue: unknown) => boolean, options?: {
+    inputType?: TypeName;
+    outputType?: TypeName;
+    severity?: "error" | "warning" | "info";
+    async?: boolean;
+    transforms?: TransformFunction<unknown, unknown>[];
+    customValidate?: (value: unknown) => {
+        valid: boolean;
+    };
+}): ComposableValidatorResult;
+/**
+ * Creates a single validator definition with metadata.
+ *
+ * @param name - The name of the validator
+ * @param check - The validation function that returns true if valid
+ * @param options - Optional metadata for the validator
+ * @returns A validator definition
+ *
+ * @example
+ * ```typescript
+ * const validator = createValidator(
+ *   "range",
+ *   (value) => value >= 0 && value <= 100,
+ *   { inputType: "number", severity: "error" }
+ * );
+ * ```
+ */
+export declare function createValidator(name: string, check: (value: unknown, currentValue: unknown) => boolean, options?: {
+    inputType?: TypeName;
+    outputType?: TypeName;
+    severity?: "error" | "warning" | "info";
+    async?: boolean;
+}): ValidatorDefinition;
+/**
+ * Composition builder context for accumulating validations
+ */
+export interface CompositionBuilder<TComposition> {
+    compositions: TComposition[];
+    add(composition: TComposition): this;
+}
+/**
+ * Creates a builder for accumulating compositions.
+ * This is useful for plugins that need to collect multiple method calls.
+ *
+ * @returns A composition builder instance
+ *
+ * @example
+ * ```typescript
+ * const builder = createCompositionBuilder<[string, number]>();
+ * builder.add(["test", 5]).add(["example", 10]);
+ * // builder.compositions now contains all added items
+ * ```
+ */
+export declare function createCompositionBuilder<TComposition>(): CompositionBuilder<TComposition>;
+/**
+ * Merges multiple validator results into a single result.
+ * All validators and transforms are combined, and validation stops at the first failure.
+ *
+ * @param results - Array of validator results to merge
+ * @returns A single merged validator result
+ *
+ * @example
+ * ```typescript
+ * const result1 = createSingleValidatorResult("min", (v) => v >= 0);
+ * const result2 = createSingleValidatorResult("max", (v) => v <= 100);
+ * const merged = mergeValidatorResults([result1, result2]);
+ * ```
+ */
+export declare function mergeValidatorResults(results: ComposableValidatorResult[]): ComposableValidatorResult;
+/**
+ * Composer that accumulates calls and builds a validator
+ */
+export interface ComposableComposer<TMethodName extends string> {
+    /**
+     * Add a call (chainable)
+     */
+    add(args: unknown[]): ComposableComposer<TMethodName>;
+    /**
+     * Build validator from accumulated calls
+     */
+    build(): ComposableValidatorResult;
+}
+export type ComposableComposerWithMethod<TMethodName extends string> = ComposableComposer<TMethodName> & {
+    [K in TMethodName]: (...args: unknown[]) => ComposableComposerWithMethod<TMethodName>;
+};
+/**
+ * Creates a composable plugin that can accumulate multiple method calls.
+ *
+ * @param name - The unique name of the plugin
+ * @param methodName - The method name that will be added to the field builder
+ * @param allowedTypes - Array of type names this plugin can be applied to
+ * @param builderFn - Function that builds validators from accumulated compositions
+ * @returns A composable plugin instance
+ *
+ * @example
+ * ```typescript
+ * // Example: Create a range check plugin that accumulates multiple ranges
+ * const rangePlugin = createComposablePlugin(
+ *   "range",
+ *   "between",
+ *   ["number"] as const,
+ *   (compositions: Array<[number, number]>, fieldPath, plugins) => {
+ *     const validators = compositions.map(([min, max], index) =>
+ *       createValidator(
+ *         `range_${index}`,
+ *         (value) => typeof value === 'number' && value >= min && value <= max,
+ *         { inputType: "number", severity: "error" }
+ *       )
+ *     );
+ *
+ *     // Custom validate function that checks all ranges
+ *     const customValidate = (value: unknown) => {
+ *       if (typeof value !== 'number') return { valid: false };
+ *       return compositions.every(([min, max]) => value >= min && value <= max)
+ *         ? { valid: true }
+ *         : { valid: false };
+ *     };
+ *
+ *     return createValidatorResult(validators, [], customValidate);
+ *   }
+ * );
+ *
+ * // Usage:
+ * builder.field("score", b => b.number.between(0, 100).between(10, 90))
+ * ```
+ */
+export declare function createComposablePlugin<TName extends string, TMethodName extends string, TAllowedTypes extends readonly TypeName[], TComposition = unknown[]>(name: TName, methodName: TMethodName, allowedTypes: TAllowedTypes, builderFn: <TPlugins>(compositions: TComposition[], fieldPath: string, plugins: TPlugins) => ComposableValidatorResult): ComposablePlugin<TName, TMethodName, TAllowedTypes>;
+/**
+ * Integration of Composable Plugin in Field Context
+ */
+export declare function attachComposablePlugin<TObject extends object, TPlugins, TBuilder>(builder: TBuilder, plugin: ComposablePlugin<string, string, readonly TypeName[]>, fieldPath: string, plugins: TPlugins): void;