@maroonedog/luq 0.1.2-alpha → 2.1.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,41 +0,0 @@
-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">;