@maroonedog/luq 0.1.0-alpha

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

@@ -0,0 +1,81 @@
+import { ValidationOptions } from "./types";
+export declare const RECURSIVE_SELF: "__Self";
+export declare const RECURSIVE_ELEMENT: "__Element";
+type RecursiveKeyword = typeof RECURSIVE_SELF | typeof RECURSIVE_ELEMENT;
+interface RecursiveOptions<TFieldPath extends RecursiveKeyword> extends ValidationOptions<{
+    targetPath: RecursiveKeyword;
+}> {
+    targetFieldPath: TFieldPath;
+    maxDepth?: number;
+}
+/**
+ * @luq-plugin
+ * @name objectRecursively
+ * @category standard
+ * @description Applies validation rules recursively to nested fields or array elements
+ * @allowedTypes ["object"]
+ * @example
+ * ```typescript
+ * // Self-referential structure using __Self
+ * type TreeNode = {
+ *   id: string;
+ *   name: string;
+ *   value: number;
+ *   parent?: TreeNode;
+ *   left?: TreeNode;
+ *   right?: TreeNode;
+ * }
+ *
+ * const validator = Builder()
+ *   .use(objectRecursivelyPlugin)
+ *   .for<TreeNode>()
+ *   .v("id", b => b.string.required())
+ *   .v("name", b => b.string.required().min(3))
+ *   .v("value", b => b.number.required().min(0))
+ *   .v("parent", b => b.object.optional().recursively("__Self"))
+ *   .v("left", b => b.object.optional().recursively("__Self"))
+ *   .v("right", b => b.object.optional().recursively("__Self"))
+ *   .build();
+ *
+ * // Array elements using __Element
+ * type Category = {
+ *   id: number;
+ *   name: string;
+ *   description?: string;
+ *   parentCategory?: Category;
+ *   subcategories: Category[];
+ * }
+ *
+ * const categoryValidator = Builder()
+ *   .use(objectRecursivelyPlugin)
+ *   .for<Category>()
+ *   .v("id", b => b.number.required().min(1))
+ *   .v("name", b => b.string.required())
+ *   .v("description", b => b.string.optional())
+ *   .v("parentCategory", b => b.object.optional().recursively("__Self"))
+ *   .v("subcategories", b => b.array.required())
+ *   .v("subcategories[*]", b => b.object.recursively("__Element"))
+ *   .build();
+ * ```
+ * @params
+ * - targetFieldPath: string | "__Self" | "__Element" - Special keywords or field path
+ * - options?: { maxDepth?: number } - Optional configuration for recursion depth
+ * @returns Validation function that marks object for recursive validation
+ * @customError
+ * ```typescript
+ * This plugin does not generate errors - it enables recursive validation
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const objectRecursivelyPlugin: import("../..").TypedPlugin<"recursively", "recursively", (targetFieldPath: RecursiveKeyword, options?: Omit<RecursiveOptions<RecursiveKeyword>, "targetFieldPath">) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (RecursiveKeyword | Omit<RecursiveOptions<RecursiveKeyword>, "targetFieldPath">)[];
+    __isRecursive: boolean;
+    recursive: {
+        targetFieldPath: RecursiveKeyword;
+        maxDepth: number;
+    };
+}, readonly ["object"], "validator", "standard">;
+export {};

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

@@ -0,0 +1,44 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name oneOf
+ * @category standard
+ * @description Validates that a value is one of the specified allowed values (enum-like validation)
+ * @allowedTypes ["string", "number", "boolean"]
+ * @example
+ * ```typescript
+ * // String enum validation
+ * const validator = Builder()
+ *   .use(oneOfPlugin)
+ *   .for<FormData>()
+ *   .v("status", (b) => b.string.oneOf(["active", "inactive", "pending"]))
+ *   .v("role", (b) => b.string.oneOf(["admin", "user", "guest"]))
+ *   .build();
+ *
+ * // Number enum validation
+ * builder.v("priority", b => b.number.oneOf([0, 1, 2, 3]))
+ *
+ * // With TypeScript const for type safety
+ * const ROLES = ["admin", "user", "guest"] as const;
+ * builder.v("userRole", b => b.string.oneOf(ROLES))
+ * ```
+ * @params
+ * - allowed: Array<string | number | boolean> - Array of allowed values
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if value is in the allowed list
+ * @customError
+ * ```typescript
+ * .oneOf(["A", "B", "C"], {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must be one of: ${params.allowed.join(", ")} (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const oneOfPlugin: import("../..").TypedPlugin<"oneOf", "oneOf", (allowedValues: readonly any[], options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (any[] | ValidationOptions<{}>)[];
+    allowedValues: readonly any[];
+}, readonly ["string", "number", "boolean"], "validator", "standard">;

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

@@ -0,0 +1,35 @@
+/**
+ * @luq-plugin
+ * @name optional
+ * @category standard
+ * @description Allows a field to be undefined (but not null or empty string)
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
+ * @example
+ * ```typescript
+ * // Basic usage - field can be undefined
+ * const validator = Builder()
+ *   .use(optionalPlugin)
+ *   .for<UserProfile>()
+ *   .v("nickname", (b) => b.string.optional().min(3))
+ *   .v("age", (b) => b.number.optional().min(0))
+ *   .build();
+ *
+ * // Arrays and objects can be optional
+ * builder.v("hobbies", b => b.array.optional().minLength(1))
+ * builder.v("settings", b => b.object.optional())
+ * ```
+ * @params
+ * No parameters - this is a modifier plugin
+ * @returns Validation function that returns true and skips further validation if value is undefined
+ * @customError
+ * This plugin does not generate errors - it allows undefined values
+ * @since 0.1.0-alpha
+ */
+export declare const optionalPlugin: import("../..").TypedPlugin<"optional", "optional", () => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: any[];
+    isOptional: boolean;
+    skipForUndefined: boolean;
+}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "standard">;

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

@@ -0,0 +1,42 @@
+import { ValidationOptions, MessageContext } from "./types";
+export interface OptionalIfContext extends MessageContext {
+    condition?: boolean;
+}
+/**
+ * @luq-plugin
+ * @name optionalIf
+ * @category conditional
+ * @description Makes a field optional based on a dynamic condition evaluated at validation time, with support for array context validation
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
+ * @example
+ * ```typescript
+ * // Basic conditional optional
+ * const validator = Builder()
+ *   .use(optionalIfPlugin)
+ *   .for<UserForm>()
+ *   .v("middleName", (b) =>
+ *     b.string.optionalIf(values => !values.includeMiddleName).min(2)
+ *   )
+ *   .build();
+ *
+ * // Phone optional if email provided
+ * builder.v("phone", b =>
+ *   b.string.optionalIf(values => !!values.email).pattern(/^\d{10}$/)
+ * )
+ * ```
+ * @params
+ * - condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean - Condition function that determines if field is optional, with access to array context
+ * @returns Validation function that skips validation when condition is true and value is empty
+ * @customError
+ * This plugin does not generate errors - it conditionally allows empty values
+ * @since 0.1.0-alpha
+ */
+export declare const optionalIfPlugin: import("../..").TypedPlugin<"optionalIf", "optionalIf", <TObject>(condition: (allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean, options?: ValidationOptions<OptionalIfContext>) => {
+    check: (value: any, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => string;
+    params: (((allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean) | ValidationOptions<OptionalIfContext>)[];
+    isOptional: boolean;
+    skipForUndefined: boolean;
+    shouldSkipValidation: (value: any, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
+}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "conditional">;

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

@@ -0,0 +1,132 @@
+import { ValidationOptions, MessageContext } from "./types";
+/**
+ * @luq-plugin
+ * @name orFail
+ * @category conditional
+ * @description Conditionally forces validation to fail with a custom error message
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union", "tuple"]
+ * @example
+ * ```typescript
+ * // Basic usage - fails when condition is true
+ * const validator = Builder()
+ *   .use(orFailPlugin)
+ *   .for<FormData>()
+ *   .v("deprecated", (b) => b.string.orFail(
+ *     values => values.useDeprecatedField === true,
+ *     { messageFactory: ({ path }) => `${path} is deprecated and should not be used` }
+ *   ))
+ *   .build();
+ *
+ * // Environment-based validation
+ * builder.v("debugData", b =>
+ *   b.object.orFail(
+ *     values => values.environment === 'production',
+ *     { messageFactory: ({ path }) => `${path} should not be present in production` }
+ *   )
+ * )
+ *
+ * // Feature flag based
+ * builder.v("betaFeature", b =>
+ *   b.string.orFail(
+ *     values => !values.betaEnabled,
+ *     { messageFactory: ({ path }) => `${path} requires beta features to be enabled` }
+ *   )
+ * )
+ * ```
+ * @params
+ * - condition: (allValues: TObject) => boolean - Condition that determines if validation should fail
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration with custom message factory
+ * @returns Validation function that fails when condition is true
+ * @customError
+ * ```typescript
+ * .orFail(
+ *   values => values.isRestricted,
+ *   {
+ *     messageFactory: ({ path, value }) => `${path} is restricted for this user (value: ${value})`
+ *   }
+ * )
+ * ```
+ * @since 0.1.0-alpha
+ */
+/**
+ * Conditionally forces validation to fail with a custom error message based on form state.
+ * This plugin is useful for marking fields as deprecated, temporarily disabled,
+ * or for implementing strict validation rules during development.
+ *
+ * Usage:
+ * ```typescript
+ * // Mark deprecated fields based on version
+ * builder.v("oldApiKey", b =>
+ *   b.string.orFail(
+ *     values => values.apiVersion >= 2,
+ *     { message: "This field is deprecated. Use 'apiToken' instead" }
+ *   )
+ * )
+ *
+ * // Temporarily disable fields based on feature flags
+ * builder.v("experimentalFeature", b =>
+ *   b.object.orFail(
+ *     values => !values.features?.experimental,
+ *     { message: "This feature is temporarily disabled" }
+ *   )
+ * )
+ *
+ * // Strict validation in production
+ * builder.v("debugInfo", b =>
+ *   b.object.orFail(
+ *     values => values.environment === 'production',
+ *     { message: "Debug information should not be included in production" }
+ *   )
+ * )
+ *
+ * // Role-based restrictions
+ * builder.v("adminSettings", b =>
+ *   b.object.orFail(
+ *     values => values.userRole !== 'admin',
+ *     { message: "Admin settings can only be modified by administrators" }
+ *   )
+ * )
+ *
+ * // Combine with other validations
+ * builder.v("restrictedField", b =>
+ *   b.string
+ *     .min(10)
+ *     .pattern(/^RESTRICTED-/)
+ *     .orFail(
+ *       values => !values.hasPermission,
+ *       { message: "This field requires special permissions" }
+ *     )
+ * )
+ * ```
+ *
+ * Note: When condition evaluates to true, the field will be invalid regardless of its value.
+ * This is useful for conditional restrictions and dynamic validation rules.
+ */
+export declare const orFailPlugin: import("../..").TypedPlugin<"orFail", "orFail", <TObject = any>(condition: (allValues: TObject) => boolean, options?: ValidationOptions & {
+    messageFactory?: (context: MessageContext) => string;
+    message?: string;
+}) => {
+    check: (value: any, allValues?: TObject) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string, allValues?: TObject) => string;
+    params: (((allValues: TObject) => boolean) | (ValidationOptions<{}> & {
+        messageFactory?: (context: MessageContext) => string;
+        message?: string;
+    }))[];
+    __isOrFail: boolean;
+    __condition: (allValues: TObject) => boolean;
+    orFail: {
+        condition: (allValues: TObject) => boolean;
+        message: string;
+        options: ValidationOptions<{}> & {
+            messageFactory?: (context: MessageContext) => string;
+            message?: string;
+        };
+        performOrFailValidation: (value: any, ctx: any) => Readonly<{
+            valid: true;
+        }> | {
+            valid: boolean;
+            message: string;
+        };
+    };
+}, readonly ["string", "number", "boolean", "array", "object", "date", "union", "tuple"], "validator", "conditional">;

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

@@ -0,0 +1,48 @@
+/**
+ * @luq-plugin
+ * @name readOnlyWriteOnly
+ * @category context
+ * @description Validates fields based on read-only or write-only context
+ * @allowedTypes ["string", "number", "boolean", "date", "array", "object"]
+ * @example
+ * ```typescript
+ * // Read-only field (should not be modified after creation)
+ * const validator = Builder()
+ *   .use(readOnlyWriteOnlyPlugin)
+ *   .for<{ id: string; name: string; }>()
+ *   .v("id", (b) => b.string.readOnly())
+ *   .v("name", (b) => b.string.required())
+ *   .build();
+ *
+ * // Write-only field (e.g., password that shouldn't be read back)
+ * builder.v("password", b => b.string.writeOnly())
+ *
+ * // With operation context
+ * const result = validator.validate(data, {
+ *   context: { operation: "read" } // or "write"
+ * });
+ * ```
+ * @params
+ * - mode?: "readOnly" | "writeOnly" - The access mode for the field
+ * - options?: { errorMessage?: string } - Optional configuration
+ * @returns Validation function that checks field access based on context
+ * @since 0.1.0-alpha
+ */
+export interface ReadOnlyWriteOnlyOptions {
+    /** Custom error message */
+    errorMessage?: string;
+    /** Whether to skip validation entirely for inaccessible fields */
+    skipValidation?: boolean;
+}
+export declare const readOnlyWriteOnlyPlugin: import("../..").TypedPlugin<"readOnlyWriteOnly", "readOnly", (options?: ReadOnlyWriteOnlyOptions) => {
+    check: (value: any, allValues: any, context?: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (string | ReadOnlyWriteOnlyOptions)[];
+}, readonly ["string", "number", "boolean", "date", "array", "object"], "validator", "context">;
+export declare const writeOnlyPlugin: import("../..").TypedPlugin<"writeOnly", "writeOnly", (options?: ReadOnlyWriteOnlyOptions) => {
+    check: (value: any, allValues: any, context?: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (string | ReadOnlyWriteOnlyOptions)[];
+}, readonly ["string", "number", "boolean", "date", "array", "object"], "validator", "context">;

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

@@ -0,0 +1,45 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name required
+ * @category standard
+ * @description Validates that a field is required (not null, undefined, or empty string)
+ * @allowedTypes ["string", "number", "boolean", "date", "array", "object", "tuple", "union"]
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const validator = Builder()
+ *   .use(requiredPlugin)
+ *   .for<UserProfile>()
+ *   .v("name", (b) => b.string.required())
+ *   .v("age", (b) => b.number.required())
+ *   .v("terms", (b) => b.boolean.required())
+ *   .build();
+ *
+ * // Custom error message
+ * builder.v("email", b => b.string.required({
+ *   messageFactory: ({ path }) => `${path} is required`
+ * }))
+ * ```
+ * @params
+ * - messageFactory?: (context: MessageContext) => string - Custom error message factory
+ * @returns Validation function that returns true if value exists (not null/undefined/empty string)
+ * @customError
+ * ```typescript
+ * .required({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} field is required (current value: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const requiredPlugin: import("../..").TypedPlugin<"required", "required", (options?: ValidationOptions & {
+    allowNull?: boolean;
+}) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (ValidationOptions<{}> & {
+        allowNull?: boolean;
+    })[];
+}, readonly ["array", "boolean", "number", "object", "string", "date", "union", "tuple"], "validator", "standard">;

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

@@ -0,0 +1,66 @@
+import { ValidationOptions, MessageContext } from "./types";
+export interface RequiredIfContext extends MessageContext {
+    condition?: boolean;
+}
+/**
+ * @luq-plugin
+ * @name requiredIf
+ * @category conditional
+ * @description Makes a field required based on a dynamic condition evaluated at validation time, with support for array context validation
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
+ * @example
+ * ```typescript
+ * // Basic conditional required
+ * const validator = Builder()
+ *   .use(requiredIfPlugin)
+ *   .for<ContactForm>()
+ *   .v("email", (b) => b.string.requiredIf(values => values.contactMethod === 'email'))
+ *   .v("phone", (b) => b.string.requiredIf(values => values.contactMethod === 'phone'))
+ *   .build();
+ *
+ * // Multiple conditions
+ * builder.v("ssn", b =>
+ *   b.string.requiredIf(values =>
+ *     values.country === 'US' && values.employmentType === 'full-time'
+ *   )
+ * )
+ *
+ * // Array context validation - conditional required within array items
+ * builder.v("items[].billingAddress", b =>
+ *   b.string.requiredIf((allValues, arrayContext) => {
+ *     // arrayContext.index: current index in array
+ *     // arrayContext.item: current object at index
+ *     // arrayContext.array: full array
+ *     return arrayContext?.item?.type === 'premium';
+ *   })
+ * )
+ *
+ * // Mixed validation - access both form values and array context
+ * builder.v("orders[].shippingAddress", b =>
+ *   b.string.requiredIf((allValues, arrayContext) => {
+ *     const isInternational = allValues.country !== 'US';
+ *     const requiresShipping = arrayContext?.item?.requiresShipping;
+ *     return isInternational && requiresShipping;
+ *   })
+ * )
+ * ```
+ * @params
+ * - condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean - Condition function that receives all form values and optional array context
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that checks if field is required based on condition
+ * @customError
+ * ```typescript
+ * .requiredIf(
+ *   (values, arrayContext) => values.hasAccount && arrayContext?.item?.isActive,
+ *   { messageFactory: ({ path }) => `${path} is required when account exists and item is active` }
+ * )
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const requiredIfPlugin: import("../..").TypedPlugin<"requiredIf", "requiredIf", <TObject>(condition: (allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean, options?: ValidationOptions<RequiredIfContext>) => {
+    check: (value: any, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string, allValues?: TObject, arrayContext?: import("./types").ArrayContext) => string;
+    params: (((allValues: TObject, arrayContext?: import("./types").ArrayContext) => boolean) | ValidationOptions<RequiredIfContext>)[];
+    evaluateCondition: (allValues?: TObject, arrayContext?: import("./types").ArrayContext) => boolean;
+}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "conditional">;

package/dist/core/plugin/shared-constants.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared constants for all plugins
+ * V8 Optimization: Frozen objects for better performance
+ */
+export declare const VALID_RESULT: Readonly<{
+    valid: true;
+}>;
+export declare const INVALID_RESULT: Readonly<{
+    valid: false;
+}>;
+export declare const ERROR_SEVERITY: "ERROR";
+/**
+ * Common error codes
+ */
+export declare const ErrorCodes: {
+    readonly MIN_VALUE: "min_value";
+    readonly MAX_VALUE: "max_value";
+    readonly MIN_LENGTH: "min_length";
+    readonly MAX_LENGTH: "max_length";
+    readonly EXACT_LENGTH: "exact_length";
+    readonly RANGE: "range";
+    readonly REQUIRED: "required";
+    readonly INVALID_TYPE: "invalid_type";
+    readonly INVALID_FORMAT: "invalid_format";
+    readonly INVALID_EMAIL: "invalid_email";
+    readonly INVALID_URL: "invalid_url";
+    readonly INVALID_UUID: "invalid_uuid";
+    readonly INVALID_DATETIME: "invalid_datetime";
+    readonly INVALID_PATTERN: "invalid_pattern";
+    readonly NOT_INTEGER: "not_integer";
+    readonly NOT_FINITE: "not_finite";
+    readonly NOT_POSITIVE: "not_positive";
+    readonly NOT_NEGATIVE: "not_negative";
+    readonly NOT_MULTIPLE: "not_multiple";
+    readonly NOT_UNIQUE: "not_unique";
+    readonly MISSING_REQUIRED: "missing_required";
+    readonly NOT_TRUTHY: "not_truthy";
+    readonly NOT_FALSY: "not_falsy";
+    readonly NOT_EQUAL: "not_equal";
+    readonly VALIDATION_ERROR: "validation_error";
+};
+/**
+ * Type for error codes
+ */
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];

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

@@ -0,0 +1,3 @@
+import { PluginValidationResult } from "../builder/plugins/plugin-interfaces";
+export declare const VALID: PluginValidationResult;
+export declare const INVALID: PluginValidationResult;

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

@@ -0,0 +1,57 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name skip
+ * @category conditional
+ * @description Completely skips validation for a field based on a dynamic condition
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
+ * @example
+ * ```typescript
+ * // Skip validation when not needed
+ * const validator = Builder()
+ *   .use(skipPlugin)
+ *   .for<FormData>()
+ *   .v("advancedOptions", b =>
+ *     b.object
+ *       .skip(values => !values.showAdvanced)
+ *       .required()
+ *   )
+ *   .build();
+ *
+ * // Skip debug fields in production
+ * builder.v("debugInfo", b =>
+ *   b.string
+ *     .skip(values => values.environment === 'production')
+ *     .min(10)
+ * )
+ *
+ * // Skip entire sections conditionally
+ * builder.v("enterpriseSettings", b =>
+ *   b.object
+ *     .skip(values => values.plan !== 'enterprise')
+ *     .recursively()
+ * )
+ * ```
+ * @params
+ * - condition: (allValues: TObject) => boolean - Function that returns true if field should be skipped
+ * - options?: ValidationOptions - Optional configuration
+ * @returns Validation function that skips field entirely when condition is true
+ * @customError
+ * ```typescript
+ * This plugin does not generate errors - it removes fields from validation
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const skipPlugin: import("../..").TypedPlugin<"skip", "skip", <TObject>(condition: (allValues: TObject) => boolean, options?: ValidationOptions) => {
+    check: (value: any, allValues?: TObject) => boolean;
+    shouldSkipAllValidation: (value: any, allValues?: TObject) => boolean;
+    code: string;
+    getErrorMessage: () => string;
+    params: (ValidationOptions<{}> | ((allValues: TObject) => boolean))[];
+    metadata: {
+        type: string;
+        category: string;
+        skipCondition: (allValues: TObject) => boolean;
+        async: boolean;
+    };
+}, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "conditional">;

package/dist/core/plugin/stitch-typed.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Type-safe Stitch Plugin with explicit type signatures
+ */
+import { NestedKeyOf } from "./types";
+import { TypeSafeStitchOptions } from "../../types/stitch-types";
+import { ValidatorFormat } from "../builder/plugins/plugin-interfaces";
+/**
+ * Create a type-safe stitch validator
+ * This function preserves all generic type parameters
+ */
+export declare function createStitchValidator<TObject, TCurrentField, const TFields extends readonly (NestedKeyOf<TObject> & string)[]>(options: TypeSafeStitchOptions<TObject, TCurrentField, TFields>): ValidatorFormat;
+/**
+ * Stitch plugin with proper type inference
+ */
+export declare const stitchPluginTyped: import("../..").TypedPlugin<"stitch", "stitch", any, readonly ["string", "number", "boolean", "date", "object", "array", "tuple", "union"], "validator", "multiFieldReference">;

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

@@ -0,0 +1 @@
+export declare const stitchPlugin: import("../..").TypedPlugin<"stitch", "stitch", any, readonly ["string", "number", "boolean", "date", "object", "array", "tuple", "union"], "validator", "multiFieldReference">;

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

@@ -0,0 +1,4 @@
+/**
+ * Export the simplified stitch plugin
+ */
+export declare const stitchSimplePlugin: import("../..").TypedPlugin<"stitch", "stitch", any, readonly ["string", "number", "boolean", "date", "object", "array", "tuple", "union"], "validator", "multiFieldReference">;