@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/core/plugin/types.d.ts

@@ -1,143 +0,0 @@
-import { NestedKeyOf } from "../../types";
-import { TypeName, TypeMapping } from "../builder/plugins/plugin-types";
-export { NestedKeyOf };
-export type ExtractTypes<T extends readonly TypeName[]> = TypeMapping[T[number]];
-export declare const SEVERITY: {
-    readonly INFO: "INFO";
-    readonly WARN: "WARN";
-    readonly ERROR: "ERROR";
-};
-export type Severity = (typeof SEVERITY)[keyof typeof SEVERITY];
-/**
- * Zod-style issue factory for generating validation errors
- * @param ctx - Context object containing field path, value, and other metadata
- * @returns Error message string
- */
-export type MessageFactory<TContext extends Record<string, any> = {}> = (ctx: MessageContext & TContext) => string;
-/**
- * Base context provided to all issue factories
- */
-export interface MessageContext {
-    path: string;
-    value: any;
-    code: string;
-}
-export interface ValidationOptions<TContext extends Record<string, any> = {}> {
-    code?: string;
-    fieldName?: string;
-    severity?: Severity;
-    messageFactory?: MessageFactory<TContext>;
-}
-export interface RecursiveContext<TObject = any> {
-    currentDepth: number;
-    rootObject: TObject;
-    parent?: any;
-    current: any;
-}
-export interface ValidationContext<TObject, TInput> {
-    originalValue: TInput;
-    currentValue: TInput;
-    allValues: TObject;
-    path: string;
-    recursiveContext?: RecursiveContext<TObject>;
-}
-/**
- * Context provided to conditional validation functions when validating array items
- * Contains information about the current array index and the object at that index
- */
-export interface ArrayContext<TItem = any> {
-    /** The current index in the array */
-    index: number;
-    /** The object at the current index */
-    item: TItem;
-    /** The full array being validated */
-    array: TItem[];
-}
-export interface ValidationFunctionReturnType {
-    valid: boolean;
-    message?: string;
-}
-export type ValidationResult = ValidationFunctionReturnType;
-export interface TransformFunctionReturnType<TOutput> extends ValidationFunctionReturnType {
-    transformData?: TOutput;
-}
-export type ValidationFunction<TObject, TInputTypes extends readonly TypeName[] | TypeName> = (value: TInputTypes extends readonly TypeName[] ? TInputTypes[number] extends TypeName ? import("../builder/plugins/plugin-types").TypeMapping[TInputTypes[number]] : never : TInputTypes extends TypeName ? import("../builder/plugins/plugin-types").TypeMapping[TInputTypes] : never, ctx: ValidationContext<TObject, TInputTypes extends readonly TypeName[] ? TInputTypes[number] : TInputTypes>) => ValidationFunctionReturnType;
-export type TransformFunction<TObject, TInputTypes extends readonly TypeName[] | TypeName> = <TOutput>(value: TInputTypes extends readonly TypeName[] ? TInputTypes[number] extends TypeName ? import("../builder/plugins/plugin-types").TypeMapping[TInputTypes[number]] : any : TInputTypes extends TypeName ? import("../builder/plugins/plugin-types").TypeMapping[TInputTypes] : any, ctx: ValidationContext<TObject, TInputTypes extends readonly TypeName[] ? TInputTypes[number] : TInputTypes>) => TransformFunctionReturnType<TOutput>;
-/**
- * Indicates that all remaining validations should be skipped
- * Used by: validateIf, skip
- */
-export interface SkipAllValidationFlag {
-    __skipAllValidation: true;
-}
-/**
- * Indicates that further validations should be skipped (but not transforms)
- * Used by: optional, optionalIf
- */
-export interface SkipFurtherValidationFlag {
-    __skipFurtherValidation: true;
-}
-/**
- * Indicates that this is a transform operation
- * Used by: transform
- */
-export interface TransformFlag<TOutput = any> {
-    __isTransform: true;
-    __transformFn: (value: any) => TOutput;
-}
-/**
- * Indicates that the field is nullable
- * Used by: nullable
- */
-export interface NullableFlag {
-    __isNullable: true;
-}
-/**
- * Indicates that the validation should be recursive
- * Used by: objectRecursively
- */
-export interface RecursiveFlag {
-    __isRecursive: true;
-}
-/**
- * Combined validation result with optional flags
- */
-export type ValidationResultWithFlags<TFlags = {}> = ValidationFunctionReturnType & TFlags;
-/**
- * Helper type to create validation results with flags
- */
-export type WithFlags<TFlags> = {
-    valid: boolean;
-    message?: string;
-} & TFlags;
-/**
- * Type guards for checking flags
- */
-export declare const ValidationFlags: {
-    isSkipAll(result: any): result is ValidationResultWithFlags<SkipAllValidationFlag>;
-    isSkipFurther(result: any): result is ValidationResultWithFlags<SkipFurtherValidationFlag>;
-    isTransform(result: any): result is ValidationResultWithFlags<TransformFlag>;
-    isNullable(result: any): result is ValidationResultWithFlags<NullableFlag>;
-    isRecursive(result: any): result is ValidationResultWithFlags<RecursiveFlag>;
-};
-/**
- * Conditional method signature that preserves the TObject type
- */
-export type ConditionalMethod<TObject = any> = {
-    validateIf?: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
-    requiredIf?: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
-    optionalIf?: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
-    skip?: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
-};
-/**
- * Type helper to create properly typed conditional plugin methods
- */
-export type WithConditionalMethods<TMethods extends Record<string, any>, TObject> = {
-    [K in keyof TMethods]: K extends keyof ConditionalMethod<TObject> ? ConditionalMethod<TObject>[K] : TMethods[K];
-};
-/**
- * Type for validateIf plugin methods
- */
-export type ValidateIfMethods<TObject = any> = {
-    validateIf: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
-};

package/dist/core/plugin/unionGuard.d.ts

@@ -1,50 +0,0 @@
-/**
- * @luq-plugin
- * @name unionGuard
- * @category composable-conditional
- * @description Validates union types by applying different validation rules based on type guards
- * @allowedTypes ["union"]
- * @example
- * ```typescript
- * // Union type validation with type guards
- * type StringOrNumber = string | number;
- *
- * const validator = Builder()
- *   .use(unionGuardPlugin)
- *   .for<{ value: StringOrNumber }>()
- *   .v("value", (b) => b.union
- *     .guard(
- *       (v): v is string => typeof v === 'string',
- *       (b) => b.string.min(3)
- *     )
- *     .guard(
- *       (v): v is number => typeof v === 'number',
- *       (b) => b.number.min(0).max(100)
- *     )
- *   )
- *   .build();
- * ```
- * @params
- * - condition: TypeGuardCondition - Type guard function that returns true if value matches the type
- * - builderFn: (context: FieldBuilderContext) => any - Builder function for the specific type
- * @returns Composable validation function that can chain multiple guards
- * @customError
- * Returns false if no guard condition matches the value
- * @since 0.1.0-alpha
- */
-/**
- * Union Guard Plugin - Composable implementation for chaining
- * Supports: guard(cond1, builder1).guard(cond2, builder2)
- */
-import type { FieldBuilderContext } from "../builder/plugins/plugin-types";
-export interface TypeGuardCondition {
-    (value: unknown): boolean;
-}
-export interface GuardBuilderFunction<TObject extends object, TPlugins> {
-    (context: FieldBuilderContext<TObject, TPlugins, any>): any;
-}
-/**
- * Union Guard Composable Plugin
- * Accumulates multiple guard calls and builds an integrated validator
- */
-export declare const unionGuardPlugin: import("../builder/plugins/composable-conditional-plugin").ComposableConditionalPlugin<"unionGuard", "guard", readonly ["union"]>;

package/dist/core/plugin/utils/field-accessor-optimized.d.ts

@@ -1,50 +0,0 @@
-/**
- * Optimized Field Accessor Utilities
- *
- * High-performance field access with:
- * - Pre-split path segments cached at build time
- * - No runtime string splitting
- * - Direct property access for common depths
- * - Minimal object allocations
- */
-/**
- * Get or cache path segments to avoid runtime splitting
- */
-export declare function getPathSegments(fieldPath: string): readonly string[];
-/**
- * Create optimized accessor function for a nested field path
- * V8 Optimization: Generate direct property access code for common depths
- */
-export declare function createAccessor(pathSegments: readonly string[]): (obj: any) => any;
-/**
- * Create accessor from dot-notation field path with caching
- */
-export declare function createFieldAccessor(fieldPath: string): (obj: any) => any;
-/**
- * Batch create accessors for multiple field paths
- * Pre-allocates array for better performance
- */
-export declare function createBatchAccessors(fieldPaths: readonly string[]): Array<{
-    fieldName: string;
-    accessor: (obj: any) => any;
-}>;
-/**
- * Create field setter with caching
- * V8 Optimization: Direct property assignment for common depths
- */
-export declare function createFieldSetter(fieldPath: string): (obj: any, value: any) => void;
-/**
- * Optimized nested value accessor with array support
- * Pre-compiles access patterns for better performance
- */
-export declare function createNestedValueAccessor(fieldPath: string): (obj: Record<string, unknown>) => unknown;
-/**
- * Pre-warm the cache with common field paths
- * @deprecated Caches have been removed to prevent memory leaks
- */
-export declare function prewarmCache(commonPaths: string[]): void;
-/**
- * Clear all caches (useful for testing)
- * @deprecated Caches have been removed to prevent memory leaks
- */
-export declare function clearAllCaches(): void;

package/dist/core/plugin/utils/field-accessor.d.ts

@@ -1,107 +0,0 @@
-/**
- * Field Accessor Utilities
- *
- * Optimized field value access with pre-created accessor functions.
- * V8 Optimization: Direct property access chains for better performance.
- */
-/**
- * Create optimized accessor function for a nested field path
- * V8 Optimization: Generate direct property access code for common depths
- *
- * @param pathSegments - Array of property keys to traverse
- * @returns Optimized accessor function
- */
-export declare function createAccessor(pathSegments: string[]): (obj: any) => any;
-/**
- * Create accessor from dot-notation field path
- *
- * @param fieldPath - Field path in dot notation (e.g., "user.profile.name")
- * @returns Optimized accessor function
- */
-export declare function createFieldAccessor(fieldPath: string): (obj: any) => any;
-/**
- * Get cached accessor or create new one
- * NOTE: Cache should be managed by the caller (e.g., validator factory)
- * to avoid global state and memory leaks
- *
- * @param fieldPath - Field path in dot notation
- * @param cache - Cache map provided by the caller
- * @returns Cached or newly created accessor function
- */
-export declare function getCachedAccessor(fieldPath: string, cache: Map<string, (obj: any) => any>): (obj: any) => any;
-/**
- * Create accessor cache factory
- * Returns a function that manages its own cache scope
- *
- * @returns Function to get cached accessors with local cache
- */
-export declare function createAccessorCacheFactory(): (fieldPath: string) => (obj: any) => any;
-/**
- * Batch create accessors for multiple field paths
- * Useful for plugins that need to access multiple fields
- *
- * @param fieldPaths - Array of field paths in dot notation
- * @returns Array of accessor objects with fieldName and accessor function
- */
-export declare function createBatchAccessors(fieldPaths: string[]): Array<{
-    fieldName: string;
-    accessor: (obj: any) => any;
-}>;
-/**
- * Create field value getter that returns values for multiple fields
- *
- * @param fieldPaths - Array of field paths to access
- * @returns Function that extracts values for all specified fields
- */
-export declare function createMultiFieldGetter(fieldPaths: string[]): (obj: any) => Record<string, any>;
-/**
- * Optimized field existence checker
- *
- * @param fieldPath - Field path in dot notation
- * @returns Function that checks if field exists (not undefined)
- */
-export declare function createFieldExistenceChecker(fieldPath: string): (obj: any) => boolean;
-/**
- * Create field setter for nested paths
- * V8 Optimization: Direct property assignment for common depths
- *
- * @param fieldPath - Field path in dot notation
- * @returns Function that sets the field value
- */
-export declare function createFieldSetter(fieldPath: string): (obj: any, value: any) => void;
-/**
- * Create optimized nested value accessor with array support
- * Handles array element validation patterns and standard nested access
- * V8 Optimization: Fast paths for common access patterns
- *
- * @param fieldPath - Field path in dot notation
- * @returns Function that gets nested values with array support
- */
-export declare function createNestedValueAccessor(fieldPath: string): (obj: Record<string, unknown>) => unknown;
-/**
- * Parse field path and detect array element notation [*]
- *
- * @param fieldPath - Field path that may contain [*] notation
- * @returns Object describing the path structure
- */
-export declare function parseFieldPath(fieldPath: string): {
-    hasArrayElements: boolean;
-    segments: Array<{
-        name: string;
-        isArrayElement: boolean;
-    }>;
-    baseArrayPath?: string;
-    elementPath?: string;
-};
-/**
- * Create accessor for array element fields with [*] notation
- * Returns array of values that should be validated individually
- *
- * @param fieldPath - Field path with [*] notation (e.g., "categories[*]", "categories[*].name")
- * @returns Function that returns array element values for validation
- */
-export declare function createArrayElementAccessor(fieldPath: string): (obj: any) => {
-    elements: any[];
-    basePath: string;
-    elementPath: string;
-} | null;

package/dist/core/plugin/uuid.d.ts

@@ -1,95 +0,0 @@
-import { ValidationOptions } from "./types";
-declare const SUPPORTED_VERSIONS: readonly [1, 3, 4, 5, 6, 7, 8];
-type UUIDVersion = (typeof SUPPORTED_VERSIONS)[number];
-/**
- * @luq-plugin
- * @name uuid
- * @category standard
- * @description Validates that a string is a valid UUID (Universally Unique Identifier)
- * @allowedTypes ["string"]
- * @see https://tools.ietf.org/html/rfc4122 - RFC 4122: A Universally Unique IDentifier (UUID) URN Namespace
- * @see https://developer.mozilla.org/en-US/docs/Glossary/UUID - MDN UUID Reference
- * @example
- * ```typescript
- * // Basic usage - validate any UUID version (RFC 4122 compliant)
- * const validator = Builder()
- *   .use(uuidPlugin)
- *   .for<Entity>()
- *   .v("id", (b) => b.string.uuid())
- *   .v("correlationId", (b) => b.string.required().uuid())
- *   .build();
- *
- * // Validate specific UUID version
- * builder.v("userId", b => b.string.uuid(4))  // UUID v4 only
- * builder.v("namespaceId", b => b.string.uuid(5))  // UUID v5 only
- * builder.v("timestamp", b => b.string.uuid(7))  // UUID v7 only (time-based)
- *
- * // ✅ VALID UUID formats (RFC 4122)
- * // UUID v1 (MAC address + timestamp based)
- * validator.parse({ id: "12345678-1234-1234-8123-123456789abc" });
- * validator.parse({ id: "f47ac10b-58cc-4372-a567-0e02b2c3d479" });
- *
- * // UUID v3 (MD5 hash based)
- * validator.parse({ id: "6ba7b810-9dad-11d1-80b4-00c04fd430c8" });
- * validator.parse({ id: "12345678-1234-3234-8123-123456789abc" });
- *
- * // UUID v4 (random)
- * validator.parse({ id: "550e8400-e29b-41d4-a716-446655440000" });
- * validator.parse({ id: "f47ac10b-58cc-4372-a567-0e02b2c3d479" });
- * validator.parse({ id: "12345678-1234-4234-9123-123456789abc" });
- *
- * // UUID v5 (SHA-1 hash based)
- * validator.parse({ id: "6ba7b811-9dad-11d1-80b4-00c04fd430c8" });
- * validator.parse({ id: "12345678-1234-5234-8123-123456789abc" });
- *
- * // UUID v6 (reordered timestamp)
- * validator.parse({ id: "1EC9414C-232A-6B00-B3C8-9E6BDECED846" });
- * validator.parse({ id: "12345678-1234-6234-9123-123456789abc" });
- *
- * // UUID v7 (Unix timestamp based)
- * validator.parse({ id: "017F22E2-79B0-7CC3-98C4-DC0C0C07398F" });
- * validator.parse({ id: "12345678-1234-7234-8123-123456789abc" });
- *
- * // UUID v8 (custom/application-specific)
- * validator.parse({ id: "12345678-1234-8234-9123-123456789abc" });
- *
- * // Case insensitive
- * validator.parse({ id: "F47AC10B-58CC-4372-A567-0E02B2C3D479" });
- * validator.parse({ id: "f47ac10b-58cc-4372-a567-0e02b2c3d479" });
- *
- * // ❌ INVALID UUID formats
- * validator.parse({ id: "not-a-uuid" });                      // Plain text
- * validator.parse({ id: "12345678-1234-1234-1234-123456789" }); // Too short
- * validator.parse({ id: "12345678-1234-1234-1234-123456789abcd" }); // Too long
- * validator.parse({ id: "12345678-1234-0234-8123-123456789abc" }); // Invalid version (0)
- * validator.parse({ id: "12345678-1234-9234-8123-123456789abc" }); // Invalid version (9)
- * validator.parse({ id: "12345678-1234-4234-0123-123456789abc" }); // Invalid variant (0)
- * validator.parse({ id: "12345678-1234-4234-c123-123456789abc" }); // Invalid variant (c)
- * validator.parse({ id: "12345678-1234-4234-g123-123456789abc" }); // Invalid hex char (g)
- * validator.parse({ id: "12345678123412348123123456789abc" });     // Missing hyphens
- * validator.parse({ id: "12345678-1234-4234-8123-123456789ab" });  // Missing last char
- * validator.parse({ id: "12345678-1234-4234-8123-123456789abcX" }); // Extra char
- * validator.parse({ id: "" });                                    // Empty string
- * validator.parse({ id: "12345678-1234-4234-8123-123456789ab " }); // Trailing space
- * validator.parse({ id: " 12345678-1234-4234-8123-123456789abc" }); // Leading space
- * ```
- * @params
- * - version?: 1 | 3 | 4 | 5 | 6 | 7 | 8 - Specific UUID version to validate (optional)
- * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
- * @returns Validation function that returns true if string is a valid UUID
- * @customError
- * ```typescript
- * .uuid(4, {
- *   messageFactory: ({ path, value, params }) =>
- *     `${path} must be a valid UUID v${params.version} (received: ${value})`
- * })
- * ```
- * @since 0.1.0-alpha
- */
-export declare const uuidPlugin: import("../..").TypedPlugin<"stringUuid", "uuid", (version?: UUIDVersion | readonly UUIDVersion[], options?: ValidationOptions) => {
-    check: (value: any) => boolean;
-    code: string;
-    getErrorMessage: (value: any, path: string) => string;
-    params: (1 | 5 | 7 | 3 | 4 | ValidationOptions<{}> | 6 | 8 | readonly (1 | 5 | 7 | 3 | 4 | 6 | 8)[])[];
-}, readonly ["string"], "validator", "standard">;
-export {};

package/dist/core/plugin/validateIf.d.ts

@@ -1,57 +0,0 @@
-import { ValidationOptions, MessageContext } from "./types";
-export interface ValidateIfContext extends MessageContext {
-    condition?: boolean;
-}
-/**
- * @luq-plugin
- * @name validateIf
- * @category conditional
- * @description Conditionally applies all validation rules to a field based on a dynamic condition, with support for array context validation
- * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
- * @example
- * ```typescript
- * // Validate URL only when custom endpoint is enabled
- * const validator = Builder()
- *   .use(validateIfPlugin)
- *   .for<ConfigData>()
- *   .v("customEndpoint", b =>
- *     b.string
- *       .validateIf(values => values.useCustomEndpoint)
- *       .url()
- *       .min(10)
- *   )
- *   .build();
- *
- * // Skip validation in local environment
- * builder.v("apiKey", b =>
- *   b.string
- *     .validateIf(values => values.environment !== 'local')
- *     .required()
- *     .min(32)
- * )
- *
- * // Conditional sections in forms
- * builder.v("businessDetails.taxId", b =>
- *   b.string
- *     .validateIf(values => values.accountType === 'business')
- *     .required()
- *     .pattern(/^\d{9}$/)
- * )
- * ```
- * @params
- * - condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean - Function that returns true if validation should run, with access to array context
- * - options?: ValidationOptions - Optional configuration
- * @returns Validation function that skips all validations when condition is false
- * @customError
- * ```typescript
- * This plugin does not generate errors - it controls whether validation runs
- * ```
- * @since 0.1.0-alpha
- */
-export declare const validateIfPlugin: import("../..").TypedPlugin<"validateIf", "validateIf", <TObject>(condition: (allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean, options?: ValidationOptions<ValidateIfContext>) => {
-    check: (value: any, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
-    code: string;
-    getErrorMessage: () => never;
-    params: (((allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean) | ValidationOptions<ValidateIfContext>)[];
-    shouldSkipAllValidation: (value: any, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
-}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "conditional">;

package/dist/core/registry/plugin-registry.d.ts

@@ -1,116 +0,0 @@
-/**
- * Plugin Registry - Shared plugin management for reusable field rules
- *
- * Enables:
- * 1. Pre-defining field validation rules with plugins
- * 2. Individual field validation before integration
- * 3. Shared plugin pools for team consistency
- */
-import { Result } from "../../types/result";
-import { ValidationOptions, ParseOptions } from "../../types";
-import type { TypedPlugin, FieldBuilderContext, ChainableFieldBuilder, PluginCategory, TypeName, PluginType } from "../builder/plugins/plugin-types";
-import { IChainableBuilder } from "../builder/core/builder";
-import type { NestedKeyOf, TypeOfPath } from "../../types/util";
-/**
- * Field Rule - Individual field validation rule with plugin support
- */
-export interface FieldRule<T> {
-    readonly _phantomType: T;
-    readonly name?: string;
-    readonly description?: string;
-    readonly fieldOptions?: import("../builder/types/field-options").FieldOptions<T>;
-    /**
-     * Validate single field value
-     */
-    validate(value: T | unknown, options?: ValidationOptions): Result<T>;
-    /**
-     * Parse single field value (with transformations)
-     */
-    parse(value: T | unknown, options?: ParseOptions): Result<T>;
-    /**
-     * Get the plugin registry used by this rule
-     */
-    getPluginRegistry(): PluginRegistry<any>;
-    /**
-     * Internal: Get validators and transforms for integration
-     * @internal
-     */
-    _getInternalValidators?: () => {
-        validators: any[];
-        transforms: any[];
-        executionPlan: any;
-    };
-}
-/**
- * Plugin Registry - Manages shared plugins for field rules with type accumulation
- */
-export interface PluginRegistry<TPlugins = {}> {
-    /**
-     * Add a plugin to the registry with type accumulation
-     */
-    use<TName extends string, TMethodName extends string, TMethod extends Function, TAllowedTypes extends readonly TypeName[] | undefined, TPluginType extends PluginType = PluginType, TCategory extends PluginCategory = PluginCategory>(plugin: TypedPlugin<TName, TMethodName, TMethod, TAllowedTypes, TPluginType, TCategory>): PluginRegistry<TPlugins & {
-        [K in TName]: TypedPlugin<TName, TMethodName, TMethod, TAllowedTypes, TPluginType, TCategory>;
-    }> & TPlugins & {
-        [K in TMethodName]: TMethod;
-    };
-    /**
-     * Create a field rule using registered plugins with practical type inference
-     */
-    createFieldRule<T>(definition: (context: FieldBuilderContext<any, TPlugins, T>) => ChainableFieldBuilder<any, TPlugins, any, T>, options?: {
-        name?: string;
-        description?: string;
-        fieldOptions?: import("../builder/types/field-options").FieldOptions<T>;
-    } | import("../builder/types/field-options").FieldConfig<T>): FieldRule<T>;
-    /**
-     * Create a builder instance using this registry's plugins
-     */
-    toBuilder(): IChainableBuilder<any, TPlugins & {
-        [K in keyof TPlugins]: TPlugins[K] extends TypedPlugin<any, any, any, any, any, any> ? TPlugins[K] : never;
-    }>;
-    /**
-     * Get all registered plugins
-     */
-    getPlugins(): Record<string, TypedPlugin<any, any, any, any, any, any>>;
-    /**
-     * Set the target type for type-safe field rule creation
-     */
-    for<TObject extends object>(): TypedPluginRegistry<TObject, TPlugins>;
-}
-/**
- * Type-safe Plugin Registry with target type specified
- */
-export interface TypedPluginRegistry<TObject extends object, TPlugins = {}> extends Omit<PluginRegistry<TPlugins>, "createFieldRule" | "for"> {
-    /**
-     * Create a field rule with type-safe field names and automatic type inference
-     */
-    createFieldRule<TName extends NestedKeyOf<TObject> & string, TExplicitType = TypeOfPath<TObject, TName>>(definition: (context: FieldBuilderContext<TObject, TPlugins, TExplicitType>) => ChainableFieldBuilder<TObject, TPlugins, any, TExplicitType>, options: {
-        name: TName;
-        description?: string;
-        fieldOptions?: import("../builder/types/field-options").FieldOptions<TExplicitType>;
-    }): FieldRule<TExplicitType>;
-    /**
-     * Create a field rule with explicit type override
-     */
-    createFieldRule<T>(definition: (context: FieldBuilderContext<any, TPlugins, T>) => ChainableFieldBuilder<any, TPlugins, any, T>, options: {
-        name: NestedKeyOf<TObject> & string;
-        description?: string;
-        fieldOptions?: import("../builder/types/field-options").FieldOptions<T>;
-    }): FieldRule<T>;
-    /**
-     * Change the target type
-     */
-    for<TNewObject extends object>(): TypedPluginRegistry<TNewObject, TPlugins>;
-}
-/**
- * Create a new plugin registry with empty plugin set
- * Generic type parameter allows TypeScript to properly track plugin accumulation
- */
-export declare function createPluginRegistry<TPlugins = {}>(): PluginRegistry<TPlugins>;
-/**
- * Type helper to extract the field type from a FieldRule
- */
-export type ExtractFieldRuleType<T> = T extends FieldRule<infer U> ? U : never;
-/**
- * Type helper for field rule definitions
- */
-export type FieldRuleDefinition<T, TPlugins = {}> = (context: FieldBuilderContext<{}, TPlugins, T>) => ChainableFieldBuilder<{}, TPlugins, any, T>;

package/dist/core/registry.d.ts

@@ -1,6 +0,0 @@
-/**
- * Luq Registry - Plugin registry functionality
- *
- * This entry point exports the plugin registry system.
- */
-export { createPluginRegistry, type PluginRegistry, type FieldRule, type ExtractFieldRuleType, type FieldRuleDefinition, type TypedPluginRegistry } from "./registry/plugin-registry";

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

@@ -1 +0,0 @@
-export * as string from "./string";

package/dist/core/transform/string/defaultValue.d.ts

@@ -1,6 +0,0 @@
-/**
- * Creates a default value transform function
- * @param defaultValue - The default value to use when input is null or undefined
- * @returns A function that returns the input value or default
- */
-export declare function createDefaultValue(defaultValue: string): (value: string | null | undefined) => string;

package/dist/core/transform/string/index.d.ts

@@ -1,3 +0,0 @@
-export { sanitize } from "./sanitize";
-export { createReplace, createReplaceAll } from "./replace";
-export { createDefaultValue } from "./defaultValue";

package/dist/core/transform/string/replace.d.ts

@@ -1,14 +0,0 @@
-/**
- * Creates a replace transform function
- * @param searchValue - The string or regex pattern to search for
- * @param replaceValue - The string to replace matches with
- * @returns A function that performs the replacement
- */
-export declare function createReplace(searchValue: string | RegExp, replaceValue: string): (value: string) => string;
-/**
- * Replaces all occurrences of a string
- * @param searchValue - The string to search for
- * @param replaceValue - The string to replace matches with
- * @returns A function that performs the replacement
- */
-export declare function createReplaceAll(searchValue: string, replaceValue: string): (value: string) => string;

package/dist/core/transform/string/sanitize.d.ts

@@ -1,6 +0,0 @@
-/**
- * Sanitizes a string by removing potentially dangerous HTML characters
- * @param value - The string value to sanitize
- * @returns The sanitized string
- */
-export declare function sanitize(value: string): string;