@maroonedog/luq 0.1.2-alpha → 2.0.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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