@maroonedog/luq 0.1.0-alpha

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

@@ -0,0 +1,40 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name stringPattern
+ * @category standard
+ * @description Validates that a string matches a regular expression pattern
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * // Basic usage - validate against regex pattern
+ * const validator = Builder()
+ *   .use(stringPatternPlugin)
+ *   .for<UserData>()
+ *   .v("phone", (b) => b.string.pattern(/^\d{3}-\d{3}-\d{4}$/))
+ *   .v("zipCode", (b) => b.string.pattern(/^\d{5}(-\d{4})?$/))
+ *   .build();
+ *
+ * // Common patterns
+ * builder.v("hexColor", b => b.string.pattern(/^#[0-9A-Fa-f]{6}$/))
+ * builder.v("slug", b => b.string.pattern(/^[a-z0-9-]+$/))
+ * ```
+ * @params
+ * - pattern: RegExp - Regular expression to match against
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if string matches the pattern
+ * @customError
+ * ```typescript
+ * .pattern(/^[A-Z]{2}\d{4}$/, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must match pattern ${params.pattern} (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const stringPatternPlugin: import("../..").TypedPlugin<"stringPattern", "pattern", (regex: RegExp | string, options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (string | RegExp | ValidationOptions<{}>)[];
+}, readonly ["string"], "validator", "standard">;

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

@@ -0,0 +1,42 @@
+/**
+ * @luq-plugin
+ * @name stringRelativeJsonPointer
+ * @category string
+ * @description Validates Relative JSON Pointer format (draft-handrews-relative-json-pointer)
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(stringRelativeJsonPointerPlugin)
+ *   .for<{ pointer: string }>()
+ *   .v("pointer", (b) => b.string.relativeJsonPointer())
+ *   .build();
+ *
+ * // Valid: 0 (current location)
+ * // Valid: 1/foo/bar (up 1 level, then to /foo/bar)
+ * // Valid: 2/0 (up 2 levels, then to index 0)
+ * // Valid: 0# (current location's key/index)
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks Relative JSON Pointer format
+ * @customError
+ * ```typescript
+ * .relativeJsonPointer({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be valid Relative JSON Pointer format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "./types";
+export declare const stringRelativeJsonPointerPlugin: import("../..").TypedPlugin<"stringRelativeJsonPointer", "relativeJsonPointer", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+    }[];
+}, readonly ["string"], "validator", "standard">;

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

@@ -0,0 +1,42 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name stringStartsWith
+ * @category standard
+ * @description Validates that a string begins with a specific prefix
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * // Basic usage - checks if string starts with prefix
+ * const validator = Builder()
+ *   .use(stringStartsWithPlugin)
+ *   .for<ApiData>()
+ *   .v("url", (b) => b.string.startsWith("https://"))
+ *   .v("apiKey", (b) => b.string.required().startsWith("sk_"))
+ *   .build();
+ *
+ * // For protocol validation
+ * builder.v("secureUrl", b => b.string.startsWith("https://").url())
+ *
+ * // For ID prefixes
+ * builder.v("orderId", b => b.string.startsWith("ORD-").pattern(/^ORD-\d{8}$/))
+ * ```
+ * @params
+ * - prefix: string - The prefix that the string must start with
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if string starts with the prefix
+ * @customError
+ * ```typescript
+ * .startsWith("REF-", {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must start with '${params.prefix}' (received: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const stringStartsWithPlugin: import("../..").TypedPlugin<"stringStartsWith", "startsWith", (prefix: string, options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (string | ValidationOptions<{}>)[];
+}, readonly ["string"], "validator", "standard">;

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

@@ -0,0 +1,39 @@
+/**
+ * @luq-plugin
+ * @name stringTime
+ * @category string
+ * @description Validates time format (HH:MM:SS or HH:MM:SS.mmm)
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(stringTimePlugin)
+ *   .for<{ startTime: string }>()
+ *   .v("startTime", (b) => b.string.time())
+ *   .build();
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string; allowMilliseconds?: boolean } - Optional configuration
+ * @returns Validation function that checks time format
+ * @customError
+ * ```typescript
+ * .time({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be a valid time format, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "./types";
+export declare const stringTimePlugin: import("../..").TypedPlugin<"stringTime", "time", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+    allowMilliseconds?: boolean;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+        allowMilliseconds?: boolean;
+    }[];
+}, readonly ["string"], "validator", "standard">;

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

@@ -0,0 +1,43 @@
+/**
+ * @luq-plugin
+ * @name stringUriTemplate
+ * @category string
+ * @description Validates URI Template format (RFC 6570)
+ * @allowedTypes ["string"]
+ * @example
+ * ```typescript
+ * const validator = Builder()
+ *   .use(stringUriTemplatePlugin)
+ *   .for<{ template: string }>()
+ *   .v("template", (b) => b.string.uriTemplate())
+ *   .build();
+ *
+ * // Valid: https://api.example.com/users/{id}
+ * // Valid: /search{?q,lang}
+ * // Valid: /path{/segments*}
+ * // Valid: {+path}/here
+ * // Valid: {#section}
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional custom error message factory
+ * @returns Validation function that checks URI Template format
+ * @customError
+ * ```typescript
+ * .uriTemplate({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be a valid URI Template, received: ${value}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+import type { MessageContext } from "./types";
+export declare const stringUriTemplatePlugin: import("../..").TypedPlugin<"stringUriTemplate", "uriTemplate", (options?: {
+    messageFactory?: (context: MessageContext) => string;
+}) => {
+    check: (value: string) => boolean;
+    code: string;
+    getErrorMessage: (value: string, path: string) => string;
+    params: {
+        messageFactory?: (context: MessageContext) => string;
+    }[];
+}, readonly ["string"], "validator", "standard">;

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

@@ -0,0 +1,97 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name stringUrl
+ * @category standard
+ * @description Validates that a string is a valid URL format
+ * @allowedTypes ["string"]
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/URL - MDN URL API Reference
+ * @see https://tools.ietf.org/html/rfc3986 - RFC 3986: Uniform Resource Identifier (URI) Generic Syntax
+ * @example
+ * ```typescript
+ * // Basic usage - validates all URL formats (RFC 3986 compliant)
+ * const validator = Builder()
+ *   .use(stringUrlPlugin)
+ *   .for<UserProfile>()
+ *   .v("website", (b) => b.string.url())
+ *   .v("profileUrl", (b) => b.string.required().url())
+ *   .build();
+ *
+ * // Custom protocols (e.g., allow ftp://)
+ * builder.v("ftpServer", b => b.string.url({
+ *   protocols: ['ftp:', 'ftps:']
+ * }))
+ *
+ * // Allow URLs without protocol (assumes https://)
+ * builder.v("domain", b => b.string.url({
+ *   allowWithoutProtocol: true
+ * }))
+ *
+ * // ✅ VALID URL formats (RFC 3986)
+ * validator.parse({ website: "https://example.com" });                    // Standard HTTPS
+ * validator.parse({ website: "http://www.test.co.uk/path?q=value#frag" }); // Full URL with query and fragment
+ * validator.parse({ website: "ftp://files.domain.com/file.txt" });        // FTP protocol
+ * validator.parse({ website: "ws://localhost:3000" });                    // WebSocket protocol
+ * validator.parse({ website: "https://subdomain.example.com:8080/api" }); // With port and path
+ * validator.parse({ website: "https://127.0.0.1:3000" });                // IP address
+ * validator.parse({ website: "https://[::1]:8080" });                    // IPv6 address
+ * validator.parse({ website: "mailto:user@example.com" });                // mailto protocol
+ * validator.parse({ website: "tel:+1-555-123-4567" });                   // tel protocol
+ * validator.parse({ website: "https://user:pass@example.com" });          // With credentials
+ *
+ * // With allowWithoutProtocol: true
+ * const flexValidator = builder.v("site", b => b.string.url({ allowWithoutProtocol: true }));
+ * flexValidator.parse({ site: "example.com" });                          // Assumes https://
+ * flexValidator.parse({ site: "www.domain.co.uk/path" });                // Assumes https://
+ *
+ * // ❌ INVALID URL formats
+ * validator.parse({ website: "not-a-url" });              // Plain text
+ * validator.parse({ website: "http://" });                // Missing host
+ * validator.parse({ website: "://missing-protocol" });    // Missing protocol
+ * validator.parse({ website: "https://" });               // Missing host after protocol
+ * validator.parse({ website: "http://.com" });            // Invalid host
+ * validator.parse({ website: "https://example." });       // Incomplete domain
+ * validator.parse({ website: "just text with spaces" });  // Contains spaces
+ * validator.parse({ website: "ftp://[invalid-ipv6]" });   // Invalid IPv6
+ * validator.parse({ website: "https://exam ple.com" });   // Space in domain
+ * validator.parse({ website: "" });                       // Empty string
+ * ```
+ * @params
+ * - options?: StringUrlOptions - URL validation configuration
+ *   - protocols?: string[] - Allowed protocols (default: all protocols allowed)
+ *   - allowWithoutProtocol?: boolean - Allow URLs without protocol (default: false)
+ *   - messageFactory?: (context: MessageContext) => string - Custom error message factory
+ * @returns Validation function that returns true if string is a valid URL
+ * @customError
+ * ```typescript
+ * .url({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be a valid URL (received: ${value})`
+ * })
+ *
+ * // Restrict to specific protocols
+ * .url({
+ *   protocols: ['https:'],
+ *   messageFactory: ({ path }) => `${path} must be a secure HTTPS URL`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export interface StringUrlOptions extends ValidationOptions {
+    /**
+     * Array of allowed protocols. Default: null (allow all protocols)
+     * @example ['http:', 'https:', 'ftp:', 'ws:', 'wss:']
+     */
+    protocols?: string[];
+    /**
+     * Whether to allow URLs without protocol (will default to https://)
+     * @default false
+     */
+    allowWithoutProtocol?: boolean;
+}
+export declare const stringUrlPlugin: import("../..").TypedPlugin<"stringUrl", "url", (options?: StringUrlOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: StringUrlOptions[];
+}, readonly ["string"], "validator", "standard">;

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

@@ -0,0 +1,15 @@
+/**
+ * Test utilities for plugin testing
+ */
+export declare const createMockReporter: () => {
+    report: jest.Mock<any, any, any>;
+    getReports: jest.Mock<any[], [], any>;
+};
+export declare const createMockContext: (path?: string) => {
+    path: string;
+    reporter: {
+        report: jest.Mock<any, any, any>;
+        getReports: jest.Mock<any[], [], any>;
+    };
+    allValues: {};
+};

package/dist/core/plugin/transform-type-restrictions.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Transform type restriction utilities
+ * Due to nested array support implementation, transform of Array<object> and Array<union>
+ * is no longer supported, so we restrict it at the type level.
+ */
+/**
+ * Type helper to determine if it's a Union type
+ * Uses the properties of distributive conditional types for detection
+ */
+type IsUnionType<T, U = T> = T extends any ? [U] extends [T] ? false : true : false;
+/**
+ * Use distributive conditional types to check if Union elements are plain objects
+ * Result becomes boolean union (e.g., false | true)
+ */
+type UnionMemberCheck<T> = T extends any ? T extends Record<string, any> ? T extends (...args: any[]) => any ? false : T extends readonly any[] ? false : T extends Date ? false : T extends RegExp ? false : T extends string | number | boolean | null | undefined ? false : true : false : false;
+/**
+ * Accurately determine if a Union type contains plain objects
+ * If true is included in the result, it's a Union containing plain objects
+ */
+type UnionHasPlainObject<T> = true extends UnionMemberCheck<T> ? true : false;
+/**
+ * More accurate approach: Detect Union type first then process
+ */
+type ArrayElementIsObjectOrUnion<T> = T extends readonly (infer U)[] ? IsUnionType<U> extends true ? UnionHasPlainObject<U> extends true ? true : false : U extends Record<string, any> ? U extends (...args: any[]) => any ? false : U extends readonly any[] ? false : U extends Date ? false : U extends RegExp ? false : U extends string | number | boolean | null | undefined ? false : true : false : false;
+/**
+ * Determine if the type is forbidden as a Transform return value
+ */
+export type IsForbiddenTransformOutput<T> = T extends readonly any[] ? ArrayElementIsObjectOrUnion<T> extends true ? true : false : false;
+/**
+ * Concise and clear English instruction message for forbidden Transform return types
+ * Includes specific instructions displayed in TypeScript errors
+ */
+export type ForbiddenTransformError<T> = T extends readonly (infer U)[] ? U extends Record<string, any> ? U extends (...args: any[]) => any | readonly any[] | Date | RegExp ? never : `🚫 FORBIDDEN: Cannot transform to Array<object>. Use Array<primitive> instead. Example: .transform(arr => arr.map(s => s.toUpperCase())) returns string[]` : `🚫 FORBIDDEN: Cannot transform to Array<union with object>. Use Array<primitive> instead. Example: .transform(arr => arr.map(s => s.length)) returns number[]` : never;
+/**
+ * Conditional type to validate Transform function return type
+ */
+export type ValidateTransformOutput<T> = IsForbiddenTransformOutput<T> extends true ? ForbiddenTransformError<T> : T;
+/**
+ * Safe Transform function type definition
+ * Returns error type for forbidden return types, otherwise returns normal function type
+ */
+export type SafeTransformFunction<TInput, TOutput> = IsForbiddenTransformOutput<TOutput> extends true ? ForbiddenTransformError<TOutput> : (value: TInput) => TOutput;
+/**
+ * More direct type checking used in actual plugin implementations
+ */
+export type RestrictedTransformFunction<TInput = any, TOutput = any> = TOutput extends readonly any[] ? ArrayElementIsObjectOrUnion<TOutput> extends true ? ForbiddenTransformError<TOutput> : (value: TInput) => TOutput : (value: TInput) => TOutput;
+/**
+ * Utility type for displaying Transform function type check results
+ */
+export type CheckTransformFunction<F> = F extends (value: any) => infer R ? IsForbiddenTransformOutput<R> extends true ? {
+    _status: "❌ FORBIDDEN";
+    _type: R;
+    _error: ForbiddenTransformError<R>;
+} : {
+    _status: "✅ ALLOWED";
+    _type: R;
+} : {
+    _status: "❓ UNKNOWN";
+    _error: "Not a valid transform function";
+};
+export {};

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

@@ -0,0 +1,35 @@
+/**
+ * @luq-plugin
+ * @name transform
+ * @category transform
+ * @description Transforms values after successful validation (type conversion, normalization, computed values)
+ * @allowedTypes ["string", "number", "boolean", "array", "object", "date", "union"]
+ * @example
+ * ```typescript
+ * // String transformation (lowercase)
+ * const validator = Builder()
+ *   .use(transformPlugin)
+ *   .for<UserData>()
+ *   .v("email", (b) =>
+ *     b.string.required().email().transform(v => v.toLowerCase())
+ *   )
+ *   .build();
+ *
+ * // Number to string conversion
+ * builder.v("age", b =>
+ *   b.number.required().min(0).transform(v => String(v))
+ * )
+ *
+ * // Array element transformation
+ * builder.v("tags", b =>
+ *   b.array.transform(tags => tags.map(t => t.trim().toLowerCase()))
+ * )
+ * ```
+ * @params
+ * - transformFn: (value: T) => U - Transform function that takes input value and returns transformed value
+ * @returns Validation function with transformation
+ * @customError
+ * Transform plugin does not generate errors. Errors in transform function are treated as exceptions.
+ * @since 0.1.0-alpha
+ */
+export declare const transformPlugin: import("../..").TypedPlugin<"transform", "transform", import("../builder/plugins/plugin-interfaces").TransformPluginImplementation<any, any>, readonly ["string", "number", "boolean", "array", "object", "date", "union"], "validator", "transform">;

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

@@ -0,0 +1,66 @@
+/**
+ * @luq-plugin
+ * @name tupleBuilder
+ * @category composable-directly
+ * @description Validates tuple types (fixed-length arrays with different types for each element)
+ * @allowedTypes ["tuple"]
+ * @example
+ * ```typescript
+ * // Fixed-length tuple - no options needed
+ * type Coordinates = [number, number];
+ *
+ * const validator = Builder()
+ *   .use(tupleBuilderPlugin)
+ *   .for<{ location: Coordinates }>()
+ *   .v("location", (b) => b.tuple
+ *     .required()
+ *     .builder(
+ *       (a) => a.number.required().min(0),
+ *       (b) => b.number.required().min(0)
+ *     )
+ *   )
+ *   .build();
+ *
+ * // Variable-length tuple with rest elements
+ * type UserData = [string, number, boolean, ...string[]];
+ *
+ * const userValidator = Builder()
+ *   .use(tupleBuilderPlugin)
+ *   .for<{ data: UserData }>()
+ *   .v("data", (b) => b.tuple
+ *     .required()
+ *     .builder(
+ *       (a) => a.string.required().min(3),     // name
+ *       (b) => b.number.required().min(0),     // age
+ *       (c) => c.boolean.required(),           // isActive
+ *       { rest: (r) => r.string.optional() }   // rest elements
+ *     )
+ *   )
+ *   .build();
+ * ```
+ * @params
+ * - ...builderFns: Array<(context: FieldBuilderContext) => any> - Builder functions for each tuple element
+ * - options?: { rest?: (context: FieldBuilderContext) => any } - Optional configuration (automatically defaults to {} when omitted)
+ * @returns Composable validation function
+ * @customError
+ * - Returns false if value is not an array
+ * - Returns false if array length doesn't match tuple definition (without rest)
+ * - Returns false if any element validation fails
+ * @since 0.1.0-alpha
+ */
+import type { FieldBuilderContext } from "../builder/plugins/plugin-types";
+export interface TupleBuilderFunction<TObject extends object, TPlugins> {
+    (context: FieldBuilderContext<TObject, TPlugins, any>): any;
+}
+export interface RestBuilderFunction<TObject extends object, TPlugins> {
+    (context: FieldBuilderContext<TObject, TPlugins, any>): any;
+}
+export interface TupleBuilderOptions<TObject extends object, TPlugins> {
+    rest?: RestBuilderFunction<TObject, TPlugins>;
+    messageFactory?: {
+        notArray?: (value: unknown) => string;
+        lengthMismatch?: (expected: number, actual: number) => string;
+        tooShort?: (minimum: number, actual: number) => string;
+    };
+}
+export declare const tupleBuilderPlugin: import("../builder/plugins/composable-directly-plugin").ComposableDirectlyPlugin<"tupleBuilder", "builder", readonly ["tuple"]>;

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

@@ -0,0 +1,143 @@
+import { NestedKeyOf } from "../../types";
+import { TypeName, TypeMapping } from "../builder/plugins/plugin-types";
+export { NestedKeyOf };
+export type ExtractTypes<T extends readonly TypeName[]> = TypeMapping[T[number]];
+export declare const SEVERITY: {
+    readonly INFO: "INFO";
+    readonly WARN: "WARN";
+    readonly ERROR: "ERROR";
+};
+export type Severity = (typeof SEVERITY)[keyof typeof SEVERITY];
+/**
+ * Zod-style issue factory for generating validation errors
+ * @param ctx - Context object containing field path, value, and other metadata
+ * @returns Error message string
+ */
+export type MessageFactory<TContext extends Record<string, any> = {}> = (ctx: MessageContext & TContext) => string;
+/**
+ * Base context provided to all issue factories
+ */
+export interface MessageContext {
+    path: string;
+    value: any;
+    code: string;
+}
+export interface ValidationOptions<TContext extends Record<string, any> = {}> {
+    code?: string;
+    fieldName?: string;
+    severity?: Severity;
+    messageFactory?: MessageFactory<TContext>;
+}
+export interface RecursiveContext<TObject = any> {
+    currentDepth: number;
+    rootObject: TObject;
+    parent?: any;
+    current: any;
+}
+export interface ValidationContext<TObject, TInput> {
+    originalValue: TInput;
+    currentValue: TInput;
+    allValues: TObject;
+    path: string;
+    recursiveContext?: RecursiveContext<TObject>;
+}
+/**
+ * Context provided to conditional validation functions when validating array items
+ * Contains information about the current array index and the object at that index
+ */
+export interface ArrayContext<TItem = any> {
+    /** The current index in the array */
+    index: number;
+    /** The object at the current index */
+    item: TItem;
+    /** The full array being validated */
+    array: TItem[];
+}
+export interface ValidationFunctionReturnType {
+    valid: boolean;
+    message?: string;
+}
+export type ValidationResult = ValidationFunctionReturnType;
+export interface TransformFunctionReturnType<TOutput> extends ValidationFunctionReturnType {
+    transformData?: TOutput;
+}
+export type ValidationFunction<TObject, TInputTypes extends readonly TypeName[] | TypeName> = (value: TInputTypes extends readonly TypeName[] ? TInputTypes[number] extends TypeName ? import("../builder/plugins/plugin-types").TypeMapping[TInputTypes[number]] : never : TInputTypes extends TypeName ? import("../builder/plugins/plugin-types").TypeMapping[TInputTypes] : never, ctx: ValidationContext<TObject, TInputTypes extends readonly TypeName[] ? TInputTypes[number] : TInputTypes>) => ValidationFunctionReturnType;
+export type TransformFunction<TObject, TInputTypes extends readonly TypeName[] | TypeName> = <TOutput>(value: TInputTypes extends readonly TypeName[] ? TInputTypes[number] extends TypeName ? import("../builder/plugins/plugin-types").TypeMapping[TInputTypes[number]] : any : TInputTypes extends TypeName ? import("../builder/plugins/plugin-types").TypeMapping[TInputTypes] : any, ctx: ValidationContext<TObject, TInputTypes extends readonly TypeName[] ? TInputTypes[number] : TInputTypes>) => TransformFunctionReturnType<TOutput>;
+/**
+ * Indicates that all remaining validations should be skipped
+ * Used by: validateIf, skip
+ */
+export interface SkipAllValidationFlag {
+    __skipAllValidation: true;
+}
+/**
+ * Indicates that further validations should be skipped (but not transforms)
+ * Used by: optional, optionalIf
+ */
+export interface SkipFurtherValidationFlag {
+    __skipFurtherValidation: true;
+}
+/**
+ * Indicates that this is a transform operation
+ * Used by: transform
+ */
+export interface TransformFlag<TOutput = any> {
+    __isTransform: true;
+    __transformFn: (value: any) => TOutput;
+}
+/**
+ * Indicates that the field is nullable
+ * Used by: nullable
+ */
+export interface NullableFlag {
+    __isNullable: true;
+}
+/**
+ * Indicates that the validation should be recursive
+ * Used by: objectRecursively
+ */
+export interface RecursiveFlag {
+    __isRecursive: true;
+}
+/**
+ * Combined validation result with optional flags
+ */
+export type ValidationResultWithFlags<TFlags = {}> = ValidationFunctionReturnType & TFlags;
+/**
+ * Helper type to create validation results with flags
+ */
+export type WithFlags<TFlags> = {
+    valid: boolean;
+    message?: string;
+} & TFlags;
+/**
+ * Type guards for checking flags
+ */
+export declare const ValidationFlags: {
+    isSkipAll(result: any): result is ValidationResultWithFlags<SkipAllValidationFlag>;
+    isSkipFurther(result: any): result is ValidationResultWithFlags<SkipFurtherValidationFlag>;
+    isTransform(result: any): result is ValidationResultWithFlags<TransformFlag>;
+    isNullable(result: any): result is ValidationResultWithFlags<NullableFlag>;
+    isRecursive(result: any): result is ValidationResultWithFlags<RecursiveFlag>;
+};
+/**
+ * Conditional method signature that preserves the TObject type
+ */
+export type ConditionalMethod<TObject = any> = {
+    validateIf?: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
+    requiredIf?: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
+    optionalIf?: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
+    skip?: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
+};
+/**
+ * Type helper to create properly typed conditional plugin methods
+ */
+export type WithConditionalMethods<TMethods extends Record<string, any>, TObject> = {
+    [K in keyof TMethods]: K extends keyof ConditionalMethod<TObject> ? ConditionalMethod<TObject>[K] : TMethods[K];
+};
+/**
+ * Type for validateIf plugin methods
+ */
+export type ValidateIfMethods<TObject = any> = {
+    validateIf: (condition: (allValues: TObject, arrayContext?: ArrayContext) => boolean, options?: ValidationOptions) => ValidationFunction<any, any>;
+};