@maroonedog/luq 0.1.0-alpha

package/dist/plugins/validateIf.d.ts

@@ -0,0 +1,57 @@
+import { ValidationOptions, MessageContext } from "../core/plugin/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("../index").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/plugins/validateIf.js

@@ -0,0 +1 @@
+"use strict";var m=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(e,n)=>{for(var r in n)m(e,r,{get:n[r],enumerable:!0})},y=(e,n,r,a)=>{if(n&&typeof n=="object"||typeof n=="function")for(let t of T(n))!d.call(e,t)&&t!==r&&m(e,t,{get:()=>n[t],enumerable:!(a=p(n,t))||a.enumerable});return e};var c=e=>y(m({},"__esModule",{value:!0}),e);var h={};g(h,{validateIfPlugin:()=>N});module.exports=c(h);var f=(e,n,r,a)=>{let o=(i=>(...l)=>{let s=i(...l);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:a}:s})(r);switch(e){case"conditional":return(i,...l)=>o(i,...l);case"fieldReference":return(i,...l)=>o(i,...l);case"multiFieldReference":return o;case"transform":return i=>o(i);case"arrayElement":return(i,...l)=>o(i,...l);case"context":return i=>o(i);default:return o}};function u(e){let{name:n,methodName:r,allowedTypes:a,category:t,impl:o}=e;return{name:n,methodName:r,allowedTypes:a,category:t,create:()=>f(t,r,o,n)}}var w=Object.freeze({valid:!0,__skipAllValidation:!0}),x=["string","number","boolean","array","object","date","union"],N=u({name:"validateIf",methodName:"validateIf",allowedTypes:x,category:"conditional",impl:(e,n)=>({check:(r,a,t)=>(!a||!e(a,t),!0),code:"validateIf",getErrorMessage:()=>{throw new Error("validateIf plugin should never generate errors")},params:[e,n],shouldSkipAllValidation:(r,a,t)=>a?!e(a,t):!1})});0&&(module.exports={validateIfPlugin});

package/dist/plugins/validateIf.mjs

@@ -0,0 +1 @@
+var u=(a,l,i,t)=>{let e=(n=>(...o)=>{let s=n(...o);return s&&typeof s=="object"&&"check"in s?{...s,pluginName:t}:s})(i);switch(a){case"conditional":return(n,...o)=>e(n,...o);case"fieldReference":return(n,...o)=>e(n,...o);case"multiFieldReference":return e;case"transform":return n=>e(n);case"arrayElement":return(n,...o)=>e(n,...o);case"context":return n=>e(n);default:return e}};function m(a){let{name:l,methodName:i,allowedTypes:t,category:r,impl:e}=a;return{name:l,methodName:i,allowedTypes:t,category:r,create:()=>u(r,i,e,l)}}var g=Object.freeze({valid:!0,__skipAllValidation:!0}),p=["string","number","boolean","array","object","date","union"],y=m({name:"validateIf",methodName:"validateIf",allowedTypes:p,category:"conditional",impl:(a,l)=>({check:(i,t,r)=>(!t||!a(t,r),!0),code:"validateIf",getErrorMessage:()=>{throw new Error("validateIf plugin should never generate errors")},params:[a,l],shouldSkipAllValidation:(i,t,r)=>t?!a(t,r):!1})});export{y as validateIfPlugin};

package/dist/types/array-type-analysis.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Build-time TypeScript type analysis for multi-dimensional arrays
+ * Enables Array<Array<Array>> pattern optimization through compile-time type inspection
+ */
+/**
+ * Extract array depth from a type at compile time
+ * Array<string> → 1
+ * Array<Array<string>> → 2
+ * Array<Array<Array<string>>> → 3
+ *
+ * Note: TypeScript's type system has limitations with recursive arithmetic,
+ * so we use a more practical approach with explicit depth levels
+ */
+export type ArrayDepth<T> = T extends readonly (infer U)[] ? U extends readonly (infer V)[] ? V extends readonly (infer W)[] ? W extends readonly (infer X)[] ? X extends readonly (infer Y)[] ? 5 : 4 : 3 : 2 : 1 : 0;
+/**
+ * Extract the final element type from nested arrays
+ * Array<Array<{name: string}>> → {name: string}
+ */
+export type ArrayElementType<T> = T extends readonly (infer U)[] ? ArrayElementType<U> : T;
+/**
+ * Generate path pattern for nested array access
+ * Depth 1 → "[i]"
+ * Depth 2 → "[i][j]"
+ * Depth 3 → "[i][j][k]"
+ */
+export type ArrayIndexPattern<Depth extends number> = Depth extends 1 ? "[i]" : Depth extends 2 ? "[i][j]" : Depth extends 3 ? "[i][j][k]" : Depth extends 4 ? "[i][j][k][l]" : Depth extends 5 ? "[i][j][k][l][m]" : string;
+/**
+ * Array structure information resolved at build time
+ */
+export interface ArrayStructureInfo<T = any> {
+    readonly depth: number;
+    readonly elementType: T;
+    readonly indexPattern: string;
+    readonly loopVariables: readonly string[];
+}
+/**
+ * Resolve array structure at compile time
+ */
+export type ResolveArrayStructure<T> = {
+    readonly depth: ArrayDepth<T>;
+    readonly elementType: ArrayElementType<T>;
+    readonly indexPattern: ArrayIndexPattern<ArrayDepth<T>>;
+    readonly loopVariables: ArrayDepth<T> extends 1 ? readonly ["i"] : ArrayDepth<T> extends 2 ? readonly ["i", "j"] : ArrayDepth<T> extends 3 ? readonly ["i", "j", "k"] : ArrayDepth<T> extends 4 ? readonly ["i", "j", "k", "l"] : ArrayDepth<T> extends 5 ? readonly ["i", "j", "k", "l", "m"] : readonly string[];
+};
+/**
+ * Build-time array structure analyzer
+ * Creates optimized validation functions based on TypeScript type information
+ */
+export declare class BuildTimeArrayAnalyzer {
+    /**
+     * Analyze array structure from TypeScript type at build time
+     * This is called during field builder analysis phase
+     */
+    static analyzeArrayStructure<T>(fieldPath: string, sampleValue?: T): ArrayStructureInfo<ArrayElementType<T>>;
+    /**
+     * Calculate array depth at runtime (fallback for type analysis)
+     */
+    private static calculateArrayDepth;
+    /**
+     * Extract element type (for validation purposes)
+     */
+    private static extractElementType;
+    /**
+     * Generate optimized validation function for multi-dimensional arrays
+     */
+    static generateOptimizedValidator<T>(structure: ArrayStructureInfo<T>, fieldPath: string, elementValidator: (element: T, path: string) => ValidationResult): (array: any) => ValidationResult;
+    /**
+     * Create nested loop validator with arbitrary depth
+     */
+    private static createNestedLoopValidator;
+    /**
+     * Generate nested loop code string
+     */
+    private static generateNestedLoopCode;
+}
+/**
+ * Validation result interface
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: Array<{
+        path: string;
+        code: string;
+        message: string;
+    }>;
+}
+/**
+ * Type-safe array field validator generator
+ * Uses TypeScript type information to create optimized validators
+ */
+export declare function createTypedArrayValidator<T>(fieldPath: string, elementValidator: (element: ArrayElementType<T>, path: string) => ValidationResult): (value: T) => ValidationResult;
+/**
+ * Compile-time type testing
+ */
+export type Test_ArrayDepth = {
+    Simple: ArrayDepth<string[]>;
+    Double: ArrayDepth<string[][]>;
+    Triple: ArrayDepth<string[][][]>;
+    Complex: ArrayDepth<Array<Array<{
+        id: number;
+        name: string;
+    }[]>>>;
+};
+export type Test_ElementType = {
+    Simple: ArrayElementType<{
+        name: string;
+    }[]>;
+    Double: ArrayElementType<{
+        name: string;
+    }[][]>;
+    Triple: ArrayElementType<{
+        name: string;
+    }[][][]>;
+};
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Minimal type definitions - only exports actually used in the codebase
+ * Optimized for bundle size by removing unused complex type definitions
+ */
+import { NestedKeyOf, TypeOfPath, ElementType } from "./util";
+import { Result, LuqValidationException } from "./result";
+export { Result, LuqValidationException };
+/**
+ * Validation result interface - used in builder/types.ts
+ */
+export type ValidationResult<T> = {
+    valid: boolean;
+    value: T | null;
+    errors: ValidationError[];
+    originalValue?: T;
+};
+/**
+ * Validation error interface - used in plugin-registry.ts
+ */
+export type ValidationError = {
+    path: string;
+    message: string;
+    code: string;
+    paths(): string[];
+};
+/**
+ * Message factory type - used in reporter.ts and plugin/types.ts
+ * Import from plugin/types for consistent definition
+ */
+import type { MessageFactory } from "../core/plugin/types";
+export type { MessageFactory };
+/**
+ * Validation options - used in registry and plugin-types
+ */
+export type ValidationOptions = {
+    /** Abort validation on first error (default: true) */
+    abortEarly?: boolean;
+    /** Abort validation on each field's first error (default: true) */
+    abortEarlyOnEachField?: boolean;
+    /** Custom message factory for error messages */
+    messageFactory?: MessageFactory;
+    /** Translation function for i18n support */
+    translate?: (key: string, params?: Record<string, any>) => string;
+    /** Context data passed to validators */
+    context?: Record<string, any>;
+};
+/**
+ * Parse options - used in registry and plugin-types
+ */
+export type ParseOptions = {
+    /** Abort parsing on first error (default: true) */
+    abortEarly?: boolean;
+    /** Abort parsing on each field's first error (default: true) */
+    abortEarlyOnEachField?: boolean;
+    /** Custom message factory for error messages */
+    messageFactory?: MessageFactory;
+    /** Translation function for i18n support */
+    translate?: (key: string, params?: Record<string, any>) => string;
+    /** Context data passed to validators */
+    context?: Record<string, any>;
+    /** Custom transform functions for post-processing */
+    transforms?: Record<string, (value: any) => any>;
+};
+export { NestedKeyOf, TypeOfPath, ElementType };
+/**
+ * Union to intersection utility type - used in plugin/types.ts
+ */
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Validator interface - simplified version for compatibility
+ */
+export interface Validator<T> {
+    validate(value: unknown): ValidationResult<T>;
+}

package/dist/types/indexed-result.d.ts

@@ -0,0 +1,44 @@
+/**
+ * True index-based Result implementation
+ * Stores only error index and generates error objects on demand
+ */
+import { ValidationError } from "./index";
+import { Result } from "./result";
+/**
+ * Error context for deferred error generation
+ */
+export interface ErrorContext {
+    path: string;
+    value: any;
+    validators?: any[];
+    errorGenerator?: (index: number, context: ErrorContext) => ValidationError;
+}
+/**
+ * Index-based validation state
+ */
+export interface IndexedValidState<T> {
+    readonly errorIndex: number;
+    readonly data?: T;
+    readonly errorContext?: ErrorContext;
+}
+/**
+ * Create index-based Result implementation
+ */
+export declare function createIndexedResult<T>(state: IndexedValidState<T>): Result<T>;
+/**
+ * Index-based Result factory
+ */
+export declare const IndexedResult: {
+    /**
+     * Create a successful result
+     */
+    ok<T>(data: T): Result<T>;
+    /**
+     * Create a failed result with error index
+     */
+    errorIndex<T>(errorIndex: number, errorContext: ErrorContext): Result<T>;
+    /**
+     * Create a failed result with pre-generated errors (for compatibility)
+     */
+    error<T>(errors: ValidationError[]): Result<T>;
+};

package/dist/types/result.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Result pattern implementation for Luq validation
+ * Provides a type-safe, functional approach to handling validation results
+ */
+import { ValidationError } from "./index";
+/**
+ * Lightweight validation exception interface
+ */
+export interface LuqValidationException {
+    readonly name: string;
+    readonly message: string;
+    readonly errors: ValidationError[];
+    toString(): string;
+}
+/**
+ * Create a validation exception (does not extend Error for performance)
+ */
+export declare function createLuqValidationException(message: string, errors: ValidationError[]): LuqValidationException;
+export declare const LuqValidationException: {
+    new (message: string, errors: ValidationError[]): LuqValidationException;
+};
+/**
+ * Represents a successful validation result
+ */
+export interface ValidResult<T> {
+    readonly isValid: true;
+    readonly data: T;
+    readonly errors: never;
+}
+/**
+ * Represents a failed validation result
+ */
+export interface InvalidResult {
+    readonly isValid: false;
+    readonly data: never;
+    readonly errors: ValidationError[];
+}
+/**
+ * Union type for validation results
+ */
+export type ValidationState<T> = ValidResult<T> | InvalidResult;
+/**
+ * Result interface providing functional validation result handling
+ * Pattern 3: Function-based interface approach
+ *
+ * @example
+ * ```typescript
+ * const result = validator.validate(data);
+ *
+ * // Check if valid
+ * if (result.isValid()) {
+ *   // unwrap data safely
+ *   const data = result.unwrap();
+ * }
+ *
+ * // Functional approach
+ * const processed = result
+ *   .map(data => ({ ...data, processed: true }))
+ *   .unwrapOr(defaultValue);
+ *
+ * // Exception approach
+ * const data = result.unwrap(); // throws if invalid
+ * ```
+ */
+export interface Result<T> {
+    /**
+     * Check if result is valid
+     */
+    isValid(): boolean;
+    /**
+     * Backward compatibility: Check if result is valid (property access)
+     */
+    readonly valid: boolean;
+    /**
+     * Check if result is invalid
+     */
+    isError(): boolean;
+    /**
+     * Get the data if valid, otherwise throw ValidationException
+     *
+     * @throws {LuqValidationException} If the result is invalid
+     */
+    unwrap(): T;
+    /**
+     * Get the data if valid, otherwise return the default value
+     */
+    unwrapOr(defaultValue: T): T;
+    /**
+     * Get the data if valid, otherwise compute default using lazy function
+     */
+    unwrapOrElse(fn: (errors: ValidationError[]) => T): T;
+    /**
+     * Transform the data if valid, leave errors unchanged
+     */
+    map<U>(fn: (data: T) => U): Result<U>;
+    /**
+     * Transform the data if valid, allowing for fallible transformation
+     */
+    flatMap<U>(fn: (data: T) => Result<U>): Result<U>;
+    /**
+     * Execute a side effect if the result is valid
+     */
+    tap(fn: (data: T) => void): Result<T>;
+    /**
+     * Execute a side effect if the result is invalid
+     */
+    tapError(fn: (errors: ValidationError[]) => void): Result<T>;
+    /**
+     * Get the data if valid, undefined otherwise
+     * Use with caution - prefer unwrapOr() or check isValid() first
+     */
+    data(): T | undefined;
+    /**
+     * Get the errors if invalid, empty array otherwise
+     */
+    readonly errors: ValidationError[];
+    /**
+     * Convert to plain object (for serialization/compatibility)
+     */
+    toPlainObject(): {
+        valid: boolean;
+        data?: T;
+        errors: ValidationError[];
+    };
+}
+/**
+ * Result implementation factory
+ */
+export declare const Result: {
+    /**
+     * Create a successful result - optimized for performance
+     */
+    ok<T>(data: T): Result<T>;
+    /**
+     * Create a failed result
+     */
+    error<T>(errors: ValidationError[]): Result<T>;
+};
+/**
+ * Utility functions for working with Results
+ */
+export declare namespace ResultUtils {
+    /**
+     * Combine multiple results into a single result containing an array
+     * If any result is invalid, returns the first error
+     */
+    function all<T>(results: Result<T>[]): Result<T[]>;
+    /**
+     * Return the first valid result, or all errors if none are valid
+     */
+    function any<T>(results: Result<T>[]): Result<T>;
+    /**
+     * Partition results into valid and invalid arrays
+     */
+    function partition<T>(results: Result<T>[]): {
+        valid: T[];
+        invalid: ValidationError[][];
+    };
+}

package/dist/types/stitch-types.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Advanced type utilities for Stitch plugin - Multi-field reference type safety
+ */
+import { NestedKeyOf, TypeOfPath } from "./util";
+/**
+ * Extract field types from an array of field paths into a typed object
+ *
+ * @example
+ * ```typescript
+ * type UserForm = { name: string; age: number; email: string; }
+ * type Fields = ["name", "age"]
+ * type Result = FieldsToObject<UserForm, Fields>
+ * // Result: { name: string; age: number; }
+ * ```
+ */
+export type FieldsToObject<T, K extends readonly (NestedKeyOf<T> & string)[]> = {
+    [P in K[number]]: TypeOfPath<T, P>;
+};
+/**
+ * More precise tuple-based field extraction for better type inference
+ * Preserves the exact relationship between field positions and types
+ */
+export type TupleFieldsToObject<T, K extends readonly [...(NestedKeyOf<T> & string)[]]> = {
+    [Index in keyof K as K[Index] extends string ? K[Index] : never]: K[Index] extends NestedKeyOf<T> & string ? TypeOfPath<T, K[Index]> : never;
+};
+/**
+ * Type-safe Stitch validation function
+ * - First argument: Object containing only the specified field values with correct types
+ * - Second argument: Current field value with its inferred type
+ * - Third argument: Complete form object with full type safety
+ */
+export type StitchValidationFn<TObject, TCurrentField, TFields extends readonly (NestedKeyOf<TObject> & string)[]> = (fieldValues: FieldsToObject<TObject, TFields>, currentValue: TCurrentField, allValues: TObject) => {
+    valid: boolean;
+    message?: string;
+};
+/**
+ * Type-safe Stitch plugin options with complete type inference
+ */
+export type TypeSafeStitchOptions<TObject, TCurrentField, TFields extends readonly (NestedKeyOf<TObject> & string)[]> = {
+    /**
+     * Array of field paths - constrained to valid nested keys of TObject
+     * Must be readonly tuple for precise type inference
+     */
+    fields: TFields;
+    /**
+     * Validation function with full type safety:
+     * - fieldValues: Extracted field types as typed object
+     * - currentValue: Current field's value with correct type
+     * - allValues: Complete form object
+     */
+    validate: StitchValidationFn<TObject, TCurrentField, TFields>;
+    /** Optional custom error code */
+    code?: string;
+    /**
+     * Optional custom error message factory with field context
+     */
+    messageFactory?: (context: {
+        path: string;
+        value: TCurrentField;
+        code: string;
+        fields: TFields;
+        fieldValues: FieldsToObject<TObject, TFields>;
+        allValues: TObject;
+    }) => string;
+};
+/**
+ * Helper type to validate that all fields exist in the object type
+ * Provides compile-time validation of field paths
+ */
+export type ValidateFieldPaths<T, K extends readonly string[]> = K extends readonly [...infer Fields] ? Fields extends readonly (NestedKeyOf<T> & string)[] ? K : never : never;
+/**
+ * Utility type for creating strongly typed field references
+ * Ensures all field paths are valid at compile time
+ */
+export type CreateStitchOptions<T, TCurrentField> = <const TFields extends readonly (NestedKeyOf<T> & string)[]>(options: TypeSafeStitchOptions<T, TCurrentField, TFields>) => TypeSafeStitchOptions<T, TCurrentField, TFields>;
+export declare const createStitchOptions: <T, TCurrentField>() => CreateStitchOptions<T, TCurrentField>;
+/**
+ * Example usage and type validation:
+ *
+ * ```typescript
+ * type EventForm = {
+ *   startDate: string;
+ *   endDate: string;
+ *   eventDate: string;
+ *   price: number;
+ *   quantity: number;
+ *   taxRate?: number;
+ * }
+ *
+ * // Type-safe usage
+ * const eventDateValidator = Builder()
+ *   .use(stitchPlugin)
+ *   .for<EventForm>()
+ *   .v("eventDate", (b) => b.string.required().stitch({
+ *     fields: ["startDate", "endDate"] as const, // ← readonly tuple for exact inference
+ *     validate: (fieldValues, eventDate, allValues) => {
+ *       // fieldValues: { startDate: string; endDate: string; }
+ *       // eventDate: string
+ *       // allValues: EventForm
+ *
+ *       const event = new Date(eventDate);
+ *       const start = new Date(fieldValues.startDate); // ← Type-safe access
+ *       const end = new Date(fieldValues.endDate);     // ← Type-safe access
+ *
+ *       // Can access any field from allValues with full type safety
+ *       const taxRate = allValues.taxRate ?? 0; // ← Optional field handling
+ *
+ *       return {
+ *         valid: event >= start && event <= end,
+ *         message: event < start
+ *           ? "Event date cannot be before start date"
+ *           : "Event date cannot be after end date"
+ *       };
+ *     }
+ *   }))
+ *   .build();
+ * ```
+ */ 

package/dist/types/util.d.ts

@@ -0,0 +1,19 @@
+import { Validator } from "./valitator";
+export type InferType<T extends Validator<any, any>> = T extends Validator<infer U, infer U> ? U : never;
+type IsPlainObject<T> = T extends object ? T extends Function ? false : T extends any[] ? false : T extends Date ? false : true : false;
+type ArrayMethodNames = keyof any[] | keyof ReadonlyArray<any>;
+type ExcludeArrayMethods<T> = T extends string ? T extends ArrayMethodNames ? never : T : T;
+type ArrayElementPaths<U, Prefix extends string, D extends number> = U extends object ? {
+    [P in Extract<keyof U, string>]: U[P] extends Array<any> ? `${Prefix}.${P}` : NonNullable<U[P]> extends Array<any> ? `${Prefix}.${P}` : never;
+}[Extract<keyof U, string>] : never;
+type NestedKeyOfWithDepth<T, D extends number = 5> = D extends 0 ? never : T extends object ? {
+    [K in Extract<keyof T, string>]: T[K] extends Array<infer U> ? U extends Array<infer V> ? // 2D array case
+    K | `${K}[*]` | `${K}[*][*]` | (V extends object ? `${K}[*][*].${ExcludeArrayMethods<NestedKeyOfWithDepth<V, [-1, 0, 1, 2, 3, 4, 5][D]>>}` : never) : // 1D array case
+    K | `${K}[*]` | (U extends object ? `${K}[*].${ExcludeArrayMethods<NestedKeyOfWithDepth<U, [-1, 0, 1, 2, 3, 4, 5][D]>>}` : never) | ArrayElementPaths<U, `${K}[*]`, D> : NonNullable<T[K]> extends Array<infer U> ? U extends Array<infer V> ? // Optional 2D array case
+    K | `${K}[*]` | `${K}[*][*]` | (V extends object ? `${K}[*][*].${ExcludeArrayMethods<NestedKeyOfWithDepth<V, [-1, 0, 1, 2, 3, 4, 5][D]>>}` : never) : // Optional 1D array case
+    K | `${K}[*]` | (U extends object ? `${K}[*].${ExcludeArrayMethods<NestedKeyOfWithDepth<U, [-1, 0, 1, 2, 3, 4, 5][D]>>}` : never) | ArrayElementPaths<U, `${K}[*]`, D> : NonNullable<T[K]> extends object ? IsPlainObject<NonNullable<T[K]>> extends true ? K | `${K}.${NestedKeyOfWithDepth<NonNullable<T[K]>, [-1, 0, 1, 2, 3, 4, 5][D]>}` : K : K;
+}[Extract<keyof T, string>] : never;
+export type NestedKeyOf<T> = NestedKeyOfWithDepth<T>;
+export type TypeOfPath<T, Path extends string> = Path extends `${infer K}[*][*][*]` ? K extends keyof T ? T[K] extends Array<Array<Array<infer U>>> ? U : never : never : Path extends `${infer K}[*][*]` ? K extends keyof T ? T[K] extends Array<Array<infer U>> ? U : never : never : Path extends `${infer K}[*]` ? K extends keyof T ? T[K] extends Array<infer U> ? U : never : never : Path extends `${infer K}.*` ? K extends keyof T ? T[K] extends Array<infer U> ? U : never : never : Path extends `${infer K}[*][*][*].${infer Rest}` ? K extends keyof T ? T[K] extends Array<Array<Array<infer U>>> ? TypeOfPath<U, Rest> : never : never : Path extends `${infer K}[*][*].${infer Rest}` ? K extends keyof T ? T[K] extends Array<Array<infer U>> ? TypeOfPath<U, Rest> : never : never : Path extends `${infer K}[*].${infer Rest}` ? K extends keyof T ? T[K] extends Array<infer U> ? TypeOfPath<U, Rest> : never : never : Path extends `${infer K}.*.${infer Rest}` ? K extends keyof T ? T[K] extends Array<infer U> ? TypeOfPath<U, Rest> : never : never : Path extends `${infer K}.${infer Rest}` ? K extends keyof T ? T[K] extends Array<infer U> ? TypeOfPath<U, Rest> : T[K] extends any ? TypeOfPath<T[K], Rest> : never : never : Path extends keyof T ? T[Path] : never;
+export type ElementType<T> = T extends Array<infer U> ? U : never;
+export {};

package/dist/types/valitator.d.ts

@@ -0,0 +1,10 @@
+import { ValidationOptions, ValidationResult } from ".";
+export interface Validator<TObject, TValue> {
+    validate(value: TValue, options?: ValidationOptions): ValidationResult<TValue>;
+}
+export interface FieldValidator<TObject, TValue, TRequiredKeys extends keyof TObject = never> {
+    validate(value: unknown, allValues: TRequiredKeys extends never ? TObject | undefined : TObject, options?: ValidationOptions): ValidationResult<TValue>;
+}
+export interface ValidatorStrategy<TObject, TValue> {
+    validate(value: unknown, options?: ValidationOptions): ValidationResult<TValue>;
+}