@maroonedog/luq 0.1.0-alpha

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

@@ -0,0 +1,60 @@
+import { ValidationOptions, MessageContext } from "./types";
+/**
+ * @luq-plugin
+ * @name custom
+ * @category standard
+ * @description Allows custom validation logic
+ * @allowedTypes ["string", "number", "boolean", "date", "array", "object", "tuple", "union"]
+ * @example
+ * ```typescript
+ * // Basic custom validation
+ * builder.v("username", b => b.string
+ *   .custom((value) => {
+ *     return !reservedUsernames.includes(value);
+ *   }, {
+ *     code: 'RESERVED_USERNAME',
+ *     messageFactory: ({ path }) => `${path} username is reserved`
+ *   })
+ * )
+ *
+ * // With access to all values
+ * builder.v("confirmPassword", b => b.string
+ *   .custom((value, rootData) => {
+ *     return value === rootData.password;
+ *   }, {
+ *     code: 'PASSWORD_MISMATCH',
+ *     messageFactory: ({ path }) => `${path} passwords do not match`
+ *   })
+ * )
+ * ```
+ * @params
+ * - validator: (value: any, rootData?: any) => boolean - Custom validation function
+ * - options?: { code?: string; messageFactory?: (context: MessageContext) => string } - Error customization
+ * @returns Validation function with custom logic
+ * @customError
+ * ```typescript
+ * .custom(
+ *   (value) => value.length > 5,
+ *   {
+ *     messageFactory: ({ path, value }) =>
+ *       `${path} custom validation failed (received: ${value})`
+ *   }
+ * )
+ * ```
+ */
+export declare const customPlugin: import("../..").TypedPlugin<"custom", "custom", (validator: (value: any, rootData?: any) => boolean | {
+    valid: boolean;
+    message?: string;
+}, options?: ValidationOptions & {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: any, rootData?: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (((value: any, rootData?: any) => boolean | {
+        valid: boolean;
+        message?: string;
+    }) | (ValidationOptions<{}> & {
+        messageFactory?: (context: MessageContext) => string;
+    }))[];
+}, readonly ["string", "number", "boolean", "date", "array", "object", "tuple", "union"], "validator", "standard">;

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

@@ -0,0 +1,150 @@
+/**
+ * fromContext Plugin - Context-based validation
+ *
+ * Generic plugin that can uniformly handle async context,
+ * allValues, and other context data
+ */
+import type { ContextValidationOptions } from "../builder/plugins/plugin-interfaces";
+/**
+ * @luq-plugin
+ * @name fromContext
+ * @category context
+ * @description Validation using context data (async context, allValues, etc.)
+ * @allowedTypes ["string", "number", "boolean", "object", "array", "date", "union", "tuple"]
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const validator = Builder()
+ *   .use(fromContextPlugin)
+ *   .for<{ email: string }>()
+ *   .v("email", (b) => b.string.required().fromContext({
+ *     validate: (email, context) => ({
+ *       valid: !context.hasEmail,
+ *       message: "Email already exists"
+ *     }),
+ *     required: true
+ *   }))
+ *   .build();
+ *
+ * // Combination with async context
+ * const asyncContext = createAsyncContext<{ hasEmail: boolean }>()
+ *   .set("hasEmail", checkEmailExists(email))
+ *   .build();
+ *
+ * const result = await validator
+ *   .withAsyncContext<{ hasEmail: boolean }>(asyncContext)
+ *   .validate({ email: "test@example.com" });
+ *
+ * // Cross-field validation (using allValues)
+ * builder.v("confirmPassword", b => b.string.fromContext({
+ *   validate: (confirmPassword, context, allValues) => ({
+ *     valid: allValues.password === confirmPassword,
+ *     message: "Password confirmation does not match"
+ *   }),
+ *   required: false // Async context not needed when using allValues
+ * }))
+ * ```
+ * @params
+ * - validate: (value, context, allValues) => { valid: boolean; message?: string } - Validation function
+ * - errorMessage?: string - Custom error message
+ * - required?: boolean - Whether context data is required (default: false)
+ * - fallbackToValid?: boolean - Whether to consider valid when no context (default: true)
+ * @returns Validation result using context data
+ * @since 0.1.0-alpha
+ */
+export declare const fromContextPlugin: import("../..").TypedPlugin<"fromContext", "fromContext", <TContext = Record<string, any>>(options: ContextValidationOptions<TContext>) => {
+    check: (value: any, allValues?: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string, allValues?: any) => string;
+    params: ContextValidationOptions<TContext>[];
+    __isFromContext: boolean;
+    __contextOptions: ContextValidationOptions<TContext>;
+    fromContext: {
+        options: ContextValidationOptions<TContext>;
+        required: boolean;
+        fallbackToValid: boolean;
+        errorMessage: string;
+        performContextValidation: (value: any, ctx: any) => {
+            valid: boolean;
+            message: string;
+        } | {
+            valid: boolean;
+            message?: undefined;
+        };
+    };
+}, readonly ["string", "number", "boolean", "object", "array", "date", "union", "tuple"], "validator", "context">;
+/**
+ * Convenient helper functions
+ */
+/**
+ * fromContext options for email duplication check
+ */
+export declare function emailDuplicationCheck(): ContextValidationOptions<{
+    hasEmail: boolean;
+}>;
+/**
+ * fromContext options for password confirmation check
+ */
+export declare function passwordConfirmation(): ContextValidationOptions<any>;
+/**
+ * fromContext options for inventory check
+ */
+export declare function inventoryCheck(): ContextValidationOptions<{
+    inventory: Array<{
+        productId: string;
+        available: number;
+    }>;
+}>;
+/**
+ * fromContext options for conditional validation
+ */
+export declare function conditionalRequired<T>(condition: (context: T, allValues: any) => boolean, message?: string): ContextValidationOptions<T>;
+/**
+ * Type-safe fromContext helper
+ */
+export declare function createTypedContextValidator<TValue, TContext>(options: ContextValidationOptions<TContext>): ContextValidationOptions<TContext>;
+/**
+ * Usage example templates
+ */
+export declare const ContextValidationTemplates: {
+    /**
+     * Email duplication check
+     */
+    emailDuplication: () => ContextValidationOptions<{
+        hasEmail: boolean;
+    }>;
+    /**
+     * Password confirmation
+     */
+    passwordConfirmation: () => ContextValidationOptions<any>;
+    /**
+     * Inventory check
+     */
+    inventoryCheck: () => ContextValidationOptions<{
+        inventory: Array<{
+            productId: string;
+            available: number;
+        }>;
+    }>;
+    /**
+     * User permission check
+     */
+    userPermission: <T extends {
+        userRole: string;
+        requiredRole: string;
+    }>() => ContextValidationOptions<T>;
+    /**
+     * Account limits check
+     */
+    accountLimits: <T extends {
+        currentCount: number;
+        maxCount: number;
+    }>() => ContextValidationOptions<T>;
+    /**
+     * Geo restriction check
+     */
+    geoRestriction: <T extends {
+        country: string;
+        allowedCountries: string[];
+    }>() => ContextValidationOptions<T>;
+};

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

@@ -0,0 +1,71 @@
+export { requiredPlugin } from "./required";
+export { optionalPlugin } from "./optional";
+export { nullablePlugin } from "./nullable";
+export { requiredIfPlugin } from "./requiredIf";
+export { optionalIfPlugin } from "./optionalIf";
+export { skipPlugin } from "./skip";
+export { validateIfPlugin } from "./validateIf";
+export { orFailPlugin } from "./orFail";
+export { oneOfPlugin } from "./oneOf";
+export { literalPlugin } from "./literal";
+export { compareFieldPlugin } from "./compareField";
+export { customPlugin } from "./custom";
+export { stitchPlugin } from "./stitch";
+export { stringMinPlugin } from "./stringMin";
+export { stringMaxPlugin } from "./stringMax";
+export { stringExactLengthPlugin } from "./stringExactLength";
+export { stringPatternPlugin } from "./stringPattern";
+export { stringEmailPlugin } from "./stringEmail";
+export { stringUrlPlugin } from "./stringUrl";
+export { stringAlphanumericPlugin } from "./stringAlphanumeric";
+export { stringStartsWithPlugin } from "./stringStartsWith";
+export { stringEndsWithPlugin } from "./stringEndsWith";
+export { stringDatetimePlugin } from "./stringDatetime";
+export { stringDatePlugin } from "./stringDate";
+export { uuidPlugin } from "./uuid";
+export { stringIpv4Plugin } from "./stringIpv4";
+export { stringIpv6Plugin } from "./stringIpv6";
+export { stringHostnamePlugin } from "./stringHostname";
+export { stringTimePlugin } from "./stringTime";
+export { stringDurationPlugin } from "./stringDuration";
+export { stringJsonPointerPlugin } from "./stringJsonPointer";
+export { stringBase64Plugin } from "./stringBase64";
+export { stringIriPlugin } from "./stringIri";
+export { stringIriReferencePlugin } from "./stringIriReference";
+export { stringUriTemplatePlugin } from "./stringUriTemplate";
+export { stringRelativeJsonPointerPlugin } from "./stringRelativeJsonPointer";
+export { stringContentEncodingPlugin } from "./stringContentEncoding";
+export { stringContentMediaTypePlugin } from "./stringContentMediaType";
+export { numberMinPlugin } from "./numberMin";
+export { numberMaxPlugin } from "./numberMax";
+export { numberPositivePlugin } from "./numberPositive";
+export { numberNegativePlugin } from "./numberNegative";
+export { numberIntegerPlugin } from "./numberInteger";
+export { numberFinitePlugin } from "./numberFinite";
+export { numberMultipleOfPlugin } from "./numberMultipleOf";
+export { numberRangePlugin } from "./numberRange";
+export { booleanTruthyPlugin } from "./booleanTruthy";
+export { booleanFalsyPlugin } from "./booleanFalsy";
+export { arrayIncludesPlugin } from "./arrayIncludes";
+export { arrayUniquePlugin } from "./arrayUnique";
+export { arrayMinLengthPlugin } from "./arrayMinLength";
+export { arrayMaxLengthPlugin } from "./arrayMaxLength";
+export { objectPlugin } from "./object";
+export { objectRecursivelyPlugin as recursivelyPlugin } from "./objectRecursively";
+export { objectRecursivelyPlugin } from "./objectRecursively";
+export { objectMinPropertiesPlugin } from "./objectMinProperties";
+export { objectMaxPropertiesPlugin } from "./objectMaxProperties";
+export { objectAdditionalPropertiesPlugin } from "./objectAdditionalProperties";
+export { transformPlugin } from "./transform";
+export { unionGuardPlugin } from "./unionGuard";
+export { tupleBuilderPlugin } from "./tupleBuilder";
+export { fromContextPlugin } from "./fromContext";
+export { jsonSchemaPlugin } from "./jsonSchema/index";
+export { jsonSchemaFullFeaturePlugin } from "./jsonSchemaFullFeature";
+export { arrayContainsPlugin } from "./arrayContains";
+export { objectPropertyNamesPlugin } from "./objectPropertyNames";
+export { objectPatternPropertiesPlugin } from "./objectPatternProperties";
+export { objectDependentRequiredPlugin } from "./objectDependentRequired";
+export { objectDependentSchemasPlugin } from "./objectDependentSchemas";
+export { readOnlyWriteOnlyPlugin } from "./readOnlyWriteOnly";
+export type { ValidationFunction, TransformFunction } from "./types";

package/dist/core/plugin/jsonSchema/dsl-converter.d.ts

@@ -0,0 +1,22 @@
+import type { JSONSchema7 } from "json-schema";
+import { LuqFieldDSL, LuqConstraints } from "./types";
+/**
+ * DSL conversion utilities
+ * Convert JSON Schema to Luq DSL and back
+ */
+/**
+ * Convert JSON Schema to Luq DSL field definitions
+ */
+export declare const convertJsonSchemaToLuqDSL: (schema: JSONSchema7, parentPath?: string, rootSchema?: JSONSchema7) => LuqFieldDSL[];
+/**
+ * Convert DSL field definition to builder function
+ */
+export declare const convertDSLToFieldDefinition: (dsl: LuqFieldDSL, customFormats?: Record<string, (value: any) => boolean>) => (builder: any) => any;
+/**
+ * Apply base type to builder chain
+ */
+export declare const applyBaseType: (chain: any, type: LuqFieldDSL["type"]) => any;
+/**
+ * Apply constraints to builder chain
+ */
+export declare const applyConstraints: (chain: any, constraints: LuqConstraints, customFormats?: Record<string, (value: any) => boolean>) => any;

package/dist/core/plugin/jsonSchema/error-generation.d.ts

@@ -0,0 +1,14 @@
+import type { JSONSchema7 } from "json-schema";
+import { ValidationError } from "./types";
+/**
+ * JSON Schema validation error generation
+ * Functions for generating detailed validation error messages
+ */
+/**
+ * Generate detailed validation errors for a value against a schema
+ */
+export declare const getDetailedValidationErrors: (value: any, schema: JSONSchema7 | boolean, customFormats?: Record<string, (value: string) => boolean>, rootSchema?: JSONSchema7, path?: string) => ValidationError[];
+/**
+ * Get validation errors for specific path only
+ */
+export declare const getSpecificValidationErrors: (value: any, schema: JSONSchema7 | boolean, targetPath: string, customFormats?: Record<string, (value: string) => boolean>, rootSchema?: JSONSchema7) => ValidationError[];

package/dist/core/plugin/jsonSchema/format-validators.d.ts

@@ -0,0 +1,20 @@
+/**
+ * JSON Schema format validation utilities
+ * Pure functions for various string format validations
+ */
+/**
+ * Format validation functions
+ */
+export declare const formatValidators: Record<string, (value: string) => boolean>;
+/**
+ * Validate a string value against a format
+ */
+export declare const validateFormat: (value: string, format: string, customFormats?: Record<string, (value: string) => boolean>) => boolean;
+/**
+ * Get all supported format names
+ */
+export declare const getSupportedFormats: () => string[];
+/**
+ * Check if a format is supported
+ */
+export declare const isFormatSupported: (format: string) => boolean;

package/dist/core/plugin/jsonSchema/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * JsonSchema Plugin - Main Entry Point
+ * Modular JSON Schema to Luq validator conversion
+ */
+export { LuqFieldDSL, LuqConstraints, JsonSchemaOptions, ValidationError } from "./types";
+export { resolveRef, resolveSchemaRef, resolveAllRefs } from "./ref-resolver";
+export { formatValidators, validateFormat, getSupportedFormats, isFormatSupported } from "./format-validators";
+export { validateValueAgainstSchema, validateType, validateMultipleTypes, validateStringConstraints, validateNumberConstraints, validateArrayConstraints, validateObjectConstraints } from "./validation-core";
+export { getDetailedValidationErrors, getSpecificValidationErrors } from "./error-generation";
+export { convertJsonSchemaToLuqDSL, convertDSLToFieldDefinition, applyConstraints, applyBaseType, applyBaseType as getBaseChain } from "./dsl-converter";
+export { jsonSchemaPlugin } from "./plugin";

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

@@ -0,0 +1,35 @@
+import type { JSONSchema7 } from "json-schema";
+import type { BuilderExtensionPlugin, FieldBuilder } from "../../builder/plugins/plugin-types";
+import { JsonSchemaOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name jsonSchema
+ * @category builder-extension
+ * @description Enables JSON Schema to Luq validator conversion
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(jsonSchemaPlugin)
+ *   .use(requiredPlugin)
+ *   .use(stringMinPlugin)
+ *   .use(stringEmailPlugin)
+ *   .for<UserData>()
+ *   .fromJsonSchema({
+ *     type: 'object',
+ *     properties: {
+ *       email: { type: 'string', format: 'email' },
+ *       age: { type: 'number', minimum: 18 }
+ *     },
+ *     required: ['email']
+ *   })
+ *   .build();
+ * ```
+ */
+/**
+ * JSON Schema integration plugin for Luq
+ */
+export declare const jsonSchemaPlugin: BuilderExtensionPlugin<"jsonSchema", "fromJsonSchema", <TBuilder extends FieldBuilder<any, any, any, any>>(schema: JSONSchema7 | unknown, options?: JsonSchemaOptions) => TBuilder>;
+export { validateValueAgainstSchema } from "./validation-core";
+export { getDetailedValidationErrors, getSpecificValidationErrors, } from "./error-generation";
+export { convertJsonSchemaToLuqDSL, convertDSLToFieldDefinition, } from "./dsl-converter";
+export { resolveRef } from "./ref-resolver";

package/dist/core/plugin/jsonSchema/ref-resolver.d.ts

@@ -0,0 +1,14 @@
+import type { JSONSchema7 } from "json-schema";
+/**
+ * Schema reference resolution utilities
+ * Pure functions for resolving JSON Schema $ref
+ */
+export declare const resolveRef: (ref: string, rootSchema: JSONSchema7, definitions?: Record<string, JSONSchema7>) => JSONSchema7;
+/**
+ * Check if schema has $ref and resolve it
+ */
+export declare const resolveSchemaRef: (schema: JSONSchema7, rootSchema?: JSONSchema7, definitions?: Record<string, JSONSchema7>) => JSONSchema7;
+/**
+ * Recursively resolve all $refs in a schema
+ */
+export declare const resolveAllRefs: (schema: JSONSchema7, rootSchema: JSONSchema7, visited?: Set<string>) => JSONSchema7;

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

@@ -0,0 +1,69 @@
+import type { JSONSchema7 } from "json-schema";
+/**
+ * DSL representation for field definitions
+ * Extracted from main jsonSchema.ts for better testability
+ */
+export interface LuqFieldDSL {
+    path: string;
+    type: "string" | "number" | "boolean" | "date" | "array" | "object" | "null" | "tuple";
+    nullable?: boolean;
+    multipleTypes?: string[];
+    allowedProperties?: string[];
+    constraints: LuqConstraints;
+}
+export interface LuqConstraints {
+    required?: boolean;
+    min?: number;
+    max?: number;
+    exclusiveMin?: number | boolean;
+    exclusiveMax?: number | boolean;
+    multipleOf?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    contentEncoding?: string;
+    contentMediaType?: string;
+    enum?: any[];
+    const?: any;
+    integer?: boolean;
+    items?: JSONSchema7 | JSONSchema7[];
+    contains?: JSONSchema7;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    additionalProperties?: boolean | JSONSchema7;
+    propertyNames?: JSONSchema7;
+    patternProperties?: Record<string, any>;
+    dependentRequired?: Record<string, string[]>;
+    minProperties?: number;
+    maxProperties?: number;
+    allOf?: JSONSchema7[];
+    anyOf?: JSONSchema7[];
+    oneOf?: JSONSchema7[];
+    not?: JSONSchema7;
+    if?: JSONSchema7;
+    then?: JSONSchema7;
+    else?: JSONSchema7;
+    conditionalValidation?: {
+        if: JSONSchema7;
+        then?: JSONSchema7;
+        else?: JSONSchema7;
+    };
+    requiredIf?: {
+        condition: JSONSchema7;
+        parentPath: string;
+    };
+}
+export interface JsonSchemaOptions {
+    strictRequired?: boolean;
+    allowAdditionalProperties?: boolean;
+    customFormats?: Record<string, (value: any) => boolean>;
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+    code: string;
+    value?: any;
+    constraint?: any;
+}

package/dist/core/plugin/jsonSchema/validation-core.d.ts

@@ -0,0 +1,29 @@
+import type { JSONSchema7 } from "json-schema";
+/**
+ * Type validation functions
+ */
+export declare const validateType: (value: any, type: string) => boolean;
+/**
+ * Validate value against multiple types (JSON Schema type array)
+ */
+export declare const validateMultipleTypes: (value: any, types: string[]) => boolean;
+/**
+ * Validate string constraints
+ */
+export declare const validateStringConstraints: (value: string, schema: JSONSchema7, customFormats?: Record<string, (value: string) => boolean>) => boolean;
+/**
+ * Validate number constraints (including integer)
+ */
+export declare const validateNumberConstraints: (value: number, schema: JSONSchema7) => boolean;
+/**
+ * Validate array constraints
+ */
+export declare const validateArrayConstraints: (value: any[], schema: JSONSchema7, customFormats?: Record<string, (value: string) => boolean>, rootSchema?: JSONSchema7) => boolean;
+/**
+ * Validate object constraints
+ */
+export declare const validateObjectConstraints: (value: Record<string, any>, schema: JSONSchema7, customFormats?: Record<string, (value: string) => boolean>, rootSchema?: JSONSchema7) => boolean;
+/**
+ * Main validation function
+ */
+export declare const validateValueAgainstSchema: (value: any, schema: JSONSchema7, customFormats?: Record<string, (value: string) => boolean>, rootSchema?: JSONSchema7) => boolean;

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

@@ -0,0 +1,31 @@
+import type { BuilderExtensionPlugin, FieldBuilder } from "../builder/plugins/plugin-types";
+import type { JSONSchema7 } from "json-schema";
+import type { JsonSchemaOptions } from "./jsonSchema/types";
+/**
+ * @luq-plugin
+ * @name jsonSchemaFullFeature
+ * @category builder-extension
+ * @description Complete JSON Schema support with all necessary plugins pre-loaded
+ * @example
+ * ```typescript
+ * // Single plugin import for full JSON Schema support
+ * const validator = Builder()
+ *   .use(jsonSchemaFullFeaturePlugin)
+ *   .fromJsonSchema({
+ *     type: 'object',
+ *     properties: {
+ *       email: { type: 'string', format: 'email' },
+ *       age: { type: 'number', minimum: 18 },
+ *       roles: {
+ *         type: 'array',
+ *         items: { type: 'string' },
+ *         uniqueItems: true
+ *       }
+ *     },
+ *     required: ['email'],
+ *     additionalProperties: false
+ *   })
+ *   .build();
+ * ```
+ */
+export declare const jsonSchemaFullFeaturePlugin: BuilderExtensionPlugin<"jsonSchemaFullFeature", "fromJsonSchema", <TBuilder extends FieldBuilder<any, any, any, any>>(schema: JSONSchema7 | unknown, options?: JsonSchemaOptions) => TBuilder>;

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

@@ -0,0 +1,40 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name literal
+ * @category standard
+ * @description Validates that a value exactly matches a specific literal value
+ * @allowedTypes ["string", "number", "boolean", "null"]
+ * @example
+ * ```typescript
+ * // String literal - exact value match
+ * const validator = Builder()
+ *   .use(literalPlugin)
+ *   .for<Config>()
+ *   .v("type", (b) => b.string.literal("user"))
+ *   .v("version", (b) => b.string.literal("v1"))
+ *   .build();
+ *
+ * // Number and boolean literals
+ * builder.v("maxRetries", b => b.number.literal(3))
+ * builder.v("enabled", b => b.boolean.literal(true))
+ * ```
+ * @params
+ * - expected: string | number | boolean | null - The exact value to match
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true only if value exactly matches expected
+ * @customError
+ * ```typescript
+ * .literal("active", {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must be exactly "${params.expected}" (received: "${value}")`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const literalPlugin: import("../..").TypedPlugin<"literal", "literal", <TValue extends string | number | boolean | null>(expectedValue: TValue, options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (ValidationOptions<{}> | TValue)[];
+}, readonly ["string", "number", "boolean", "null"], "validator", "standard">;

package/dist/core/plugin/message-factories.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Minimal message factory implementation
+ * Provides basic resolveMessage function for reporter.ts
+ */
+import { MessageFactory, MessageContext } from "./types";
+/**
+ * Helper to resolve error message from message factory
+ */
+export declare function resolveMessage<TContext extends Record<string, any>>(messageFactory: MessageFactory<TContext>, context: MessageContext & TContext): string;

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

@@ -0,0 +1,34 @@
+/**
+ * @luq-plugin
+ * @name nullable
+ * @category standard
+ * @description Allows a field to accept null as a valid value
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
+ * @example
+ * ```typescript
+ * // Basic usage - field can be null or valid string
+ * const validator = Builder()
+ *   .use(nullablePlugin)
+ *   .for<UserProfile>()
+ *   .v("middleName", (b) => b.string.nullable().min(3))
+ *   .v("avatar", (b) => b.string.nullable().url())
+ *   .build();
+ *
+ * // With other validations - null bypasses all validators
+ * builder.v("score", b => b.number.nullable().min(0).max(100))
+ * ```
+ * @params
+ * No parameters - this is a modifier plugin
+ * @returns Validation function that returns true for null values and continues validation for non-null values
+ * @customError
+ * This plugin does not generate errors - it allows null values
+ * @since 0.1.0-alpha
+ */
+export declare const nullablePlugin: import("../..").TypedPlugin<"nullable", "nullable", () => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: any[];
+    isNullable: boolean;
+    skipForNull: boolean;
+}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "standard">;

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

@@ -0,0 +1,41 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name numberFinite
+ * @category standard
+ * @description Validates that a number is finite (not Infinity, -Infinity, or NaN)
+ * @allowedTypes ["number"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensures number is finite
+ * const validator = Builder()
+ *   .use(numberFinitePlugin)
+ *   .for<CalculationResult>()
+ *   .v("score", (b) => b.number.finite())
+ *   .v("ratio", (b) => b.number.required().finite())
+ *   .build();
+ *
+ * // For division results that might be infinite
+ * builder.v("average", b => b.number.finite().min(0))
+ *
+ * // For mathematical calculations
+ * builder.v("result", b => b.number.required().finite().range(-1000, 1000))
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if number is finite
+ * @customError
+ * ```typescript
+ * .finite({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be a finite number (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const numberFinitePlugin: import("../..").TypedPlugin<"numberFinite", "finite", (options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: ValidationOptions<{}>[];
+}, readonly ["number"], "validator", "standard">;