@maroonedog/luq 0.1.0-alpha

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

@@ -0,0 +1,50 @@
+/**
+ * @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

@@ -0,0 +1,50 @@
+/**
+ * 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

@@ -0,0 +1,107 @@
+/**
+ * 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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,116 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

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

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

@@ -0,0 +1,6 @@
+/**
+ * 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

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

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

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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;

package/dist/core/utils/type-guards.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Common type guard utilities
+ * Centralizes type checking logic to reduce code duplication and bundle size
+ */
+/**
+ * Checks if a value is a non-null object (excluding arrays)
+ */
+export declare const isObject: (value: unknown) => value is object;
+/**
+ * Checks if a value is a plain object (not Date, RegExp, etc.)
+ */
+export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Checks if a value is a string
+ */
+export declare const isString: (value: unknown) => value is string;
+/**
+ * Checks if a value is a number
+ */
+export declare const isNumber: (value: unknown) => value is number;
+/**
+ * Checks if a value is a boolean
+ */
+export declare const isBoolean: (value: unknown) => value is boolean;
+/**
+ * Checks if a value is a function
+ */
+export declare const isFunction: (value: unknown) => value is Function;
+/**
+ * Checks if a value is an array
+ */
+export declare const isArray: (arg: any) => arg is any[];
+/**
+ * Checks if a value is null or undefined
+ */
+export declare const isNullish: (value: unknown) => value is null | undefined;
+/**
+ * Checks if a value is undefined
+ */
+export declare const isUndefined: (value: unknown) => value is undefined;
+/**
+ * Checks if a value is null
+ */
+export declare const isNull: (value: unknown) => value is null;
+/**
+ * Checks if a value is an Error instance
+ */
+export declare const isError: (value: unknown) => value is Error;
+/**
+ * Checks if an object has a specific property
+ */
+export declare const hasProperty: <T extends object, K extends PropertyKey>(obj: T, key: K) => obj is T & Record<K, unknown>;
+/**
+ * Checks if a value is a valid Date
+ */
+export declare const isValidDate: (value: unknown) => value is Date;
+/**
+ * Checks if a value is a finite number
+ */
+export declare const isFiniteNumber: (value: unknown) => value is number;
+/**
+ * Checks if a value is an integer
+ */
+export declare const isInteger: (value: unknown) => value is number;
+/**
+ * Type guard for checking multiple types at once
+ */
+export declare const isOneOfTypes: <T extends readonly unknown[]>(value: unknown, guards: Array<(value: unknown) => value is T[number]>) => value is T[number];

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Luq - TypeScript validation library
+ *
+ * Single entry point for all Luq functionality.
+ * This file exports everything from the library.
+ */
+export { Builder } from "./core/builder/core/builder";
+export { createPluginRegistry, type PluginRegistry, type FieldRule, type ExtractFieldRuleType, type FieldRuleDefinition } from "./core/registry/plugin-registry";
+export { type FieldBuilder, type TransformAwareValidator, type ApplyFieldTransforms, type ExtractFieldType, type TypedPlugin, type PluginType, type PluginCategory, type TypeName, type BuilderExtensionPlugin, type BuilderExtensionMethod, } from "./core/builder/plugins/plugin-types";
+export { ValidationResult } from "./core/builder/plugins/plugin-types";
+export { type ValidationOptions, type MessageContext, type SEVERITY, } from "./core/plugin/types";
+export { type PluginValidationResult as BasicValidationResult, type StandardPluginImplementation, type ConditionalPluginImplementation, type TransformPluginImplementation, type FieldReferencePluginImplementation, type ArrayElementPluginImplementation, } from "./core/builder/plugins/plugin-interfaces";
+export { plugin, type PluginImplementation, pluginPredefinedTransform, pluginConfigurableTransform, pluginBuilderExtension, } from "./core/builder/plugins/plugin-creator";
+export { Result } from "./types/result";
+export { GlobalConfig, globalConfig, setGlobalConfig, getGlobalConfig, resetGlobalConfig, } from "./core/global-config";
+export { requiredPlugin } from "./core/plugin/required";
+export { optionalPlugin } from "./core/plugin/optional";
+export { nullablePlugin } from "./core/plugin/nullable";
+export { stringMinPlugin } from "./core/plugin/stringMin";
+export { stringMaxPlugin } from "./core/plugin/stringMax";
+export { stringEmailPlugin } from "./core/plugin/stringEmail";
+export { stringPatternPlugin } from "./core/plugin/stringPattern";
+export { stringUrlPlugin } from "./core/plugin/stringUrl";
+export { stringDatePlugin } from "./core/plugin/stringDate";
+export { stringDatetimePlugin } from "./core/plugin/stringDatetime";
+export { stringTimePlugin } from "./core/plugin/stringTime";
+export { stringIpv4Plugin } from "./core/plugin/stringIpv4";
+export { stringIpv6Plugin } from "./core/plugin/stringIpv6";
+export { stringHostnamePlugin } from "./core/plugin/stringHostname";
+export { stringDurationPlugin } from "./core/plugin/stringDuration";
+export { stringBase64Plugin } from "./core/plugin/stringBase64";
+export { stringJsonPointerPlugin } from "./core/plugin/stringJsonPointer";
+export { stringRelativeJsonPointerPlugin } from "./core/plugin/stringRelativeJsonPointer";
+export { stringIriPlugin } from "./core/plugin/stringIri";
+export { stringIriReferencePlugin } from "./core/plugin/stringIriReference";
+export { stringUriTemplatePlugin } from "./core/plugin/stringUriTemplate";
+export { stringContentEncodingPlugin } from "./core/plugin/stringContentEncoding";
+export { stringContentMediaTypePlugin } from "./core/plugin/stringContentMediaType";
+export { uuidPlugin } from "./core/plugin/uuid";
+export { numberMinPlugin } from "./core/plugin/numberMin";
+export { numberMaxPlugin } from "./core/plugin/numberMax";
+export { numberPositivePlugin } from "./core/plugin/numberPositive";
+export { numberNegativePlugin } from "./core/plugin/numberNegative";
+export { numberIntegerPlugin } from "./core/plugin/numberInteger";
+export { numberMultipleOfPlugin } from "./core/plugin/numberMultipleOf";
+export { booleanTruthyPlugin } from "./core/plugin/booleanTruthy";
+export { booleanFalsyPlugin } from "./core/plugin/booleanFalsy";
+export { arrayMinLengthPlugin } from "./core/plugin/arrayMinLength";
+export { arrayMaxLengthPlugin } from "./core/plugin/arrayMaxLength";
+export { arrayUniquePlugin } from "./core/plugin/arrayUnique";
+export { arrayIncludesPlugin } from "./core/plugin/arrayIncludes";
+export { arrayContainsPlugin } from "./core/plugin/arrayContains";
+export { objectPlugin } from "./core/plugin/object";
+export { objectMinPropertiesPlugin } from "./core/plugin/objectMinProperties";
+export { objectMaxPropertiesPlugin } from "./core/plugin/objectMaxProperties";
+export { objectAdditionalPropertiesPlugin } from "./core/plugin/objectAdditionalProperties";
+export { objectPropertyNamesPlugin } from "./core/plugin/objectPropertyNames";
+export { objectPatternPropertiesPlugin } from "./core/plugin/objectPatternProperties";
+export { objectDependentRequiredPlugin } from "./core/plugin/objectDependentRequired";
+export { objectDependentSchemasPlugin } from "./core/plugin/objectDependentSchemas";
+export { oneOfPlugin } from "./core/plugin/oneOf";
+export { literalPlugin } from "./core/plugin/literal";
+export { compareFieldPlugin } from "./core/plugin/compareField";
+export { requiredIfPlugin } from "./core/plugin/requiredIf";
+export { validateIfPlugin } from "./core/plugin/validateIf";
+export { skipPlugin } from "./core/plugin/skip";
+export { transformPlugin } from "./core/plugin/transform";
+export { tupleBuilderPlugin } from "./core/plugin/tupleBuilder";
+export { readOnlyWriteOnlyPlugin } from "./core/plugin/readOnlyWriteOnly";
+export { customPlugin } from "./core/plugin/custom";
+export { jsonSchemaPlugin } from "./core/plugin/jsonSchema";
+export { jsonSchemaFullFeaturePlugin } from "./core/plugin/jsonSchemaFullFeature";