@maroonedog/luq 0.1.0-alpha

package/dist/core/optimization/core/strategy-factory.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Strategy Pattern Implementation
+ * Validation strategy integration and factory pattern
+ */
+import { ValidationEngine, ValidationField, ValidationResult, ParseResult } from "./validation-engine";
+export declare enum ValidationStrategy {
+    FAST_SEPARATED = "fast_separated",
+    DEFINITION_ORDER = "definition_order",
+    ARRAY_BATCH = "array_batch",
+    HOISTED_OPTIMIZED = "hoisted_optimized"
+}
+export interface StrategyValidationOptions {
+    abortEarly?: boolean;
+    abortEarlyOnEachField?: boolean;
+}
+export interface StrategyAnalysis {
+    strategy: ValidationStrategy;
+    reason: string;
+    canOptimize: boolean;
+    hasTransforms: boolean;
+    hasArrayFields: boolean;
+    fieldCount: number;
+}
+/**
+ * Unified validation strategy interface
+ */
+export interface IValidationStrategy {
+    readonly strategyType: ValidationStrategy;
+    validate(value: any, rootData: any, options?: StrategyValidationOptions): ValidationResult;
+    parse(value: any, rootData: any, options?: StrategyValidationOptions): ParseResult;
+    validateHoisted?(value: any, rootData: any, abortEarlyOnEachField?: boolean): {
+        valid: boolean;
+        errorIndices?: number[];
+    };
+    reconstructErrors?(errorIndices: number[], value: any, rootData: any, abortEarlyOnEachField?: boolean): Array<{
+        path: string;
+        code: string;
+        message: string;
+    }>;
+}
+/**
+ * Fast Separated Strategy
+ * Execute in order: Validators → Transforms (optimized)
+ */
+export declare function createFastSeparatedStrategy(field: ValidationField, engine?: ValidationEngine): IValidationStrategy;
+/**
+ * Definition Order Strategy
+ * Execute in definition order (including transforms)
+ */
+export declare function createDefinitionOrderStrategy(field: ValidationField, engine?: ValidationEngine): IValidationStrategy;
+/**
+ * Array Batch Strategy
+ * Batch processing of array elements (optimized)
+ */
+export declare function createArrayBatchStrategy(arrayPath: string, elementFields: ValidationField[], engine?: ValidationEngine): IValidationStrategy;
+/**
+ * Multi-Field Strategy
+ * Integrated processing of multiple fields
+ */
+export declare function createMultiFieldStrategy(fields: ValidationField[], engine?: ValidationEngine): IValidationStrategy;
+/**
+ * Analyze field definitions to determine optimal strategy
+ */
+export declare function analyzeFields(fieldDefinitions: Array<{
+    path: string;
+    builderFunction: Function;
+}>, plugins: Record<string, any>): StrategyAnalysis;
+/**
+ * Create strategy instance
+ */
+export declare function createStrategy(analysis: StrategyAnalysis, fieldDefinitions: Array<{
+    path: string;
+    builderFunction: Function;
+    validators?: any[];
+    transforms?: any[];
+}>, plugins: Record<string, any>): IValidationStrategy;
+export declare function createOptimalStrategy(fieldDefinitions: Array<{
+    path: string;
+    builderFunction: Function;
+}>, plugins: Record<string, any>): {
+    strategy: IValidationStrategy;
+    analysis: StrategyAnalysis;
+};
+export declare function createSingleFieldStrategy(path: string, validators: any[], transforms?: any[]): IValidationStrategy;

package/dist/core/optimization/core/validation-engine.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Core Validation Engine
+ * Integrated validation execution engine - eliminates duplicate logic
+ */
+export interface ValidationError {
+    path: string;
+    code: string;
+    message: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+export interface ParseResult extends ValidationResult {
+    data?: any;
+}
+export interface ValidationContext {
+    originalValue: any;
+    currentValue: any;
+    allValues: any;
+    path: string;
+    arrayContext?: import("../../plugin/types").ArrayContext;
+}
+export interface ValidatorFunction {
+    check: (value: any, allValues?: any, arrayContext?: import("../../plugin/types").ArrayContext) => boolean;
+    code?: string;
+    pluginName?: string;
+    getErrorMessage?: (value: any, path: string, allValues?: any, arrayContext?: import("../../plugin/types").ArrayContext) => string;
+    messageFactory?: (context: any) => string;
+    params?: any[];
+    metadata?: {
+        type?: string;
+        category?: string;
+        [key: string]: any;
+    };
+}
+export interface TransformFunction {
+    apply?: (value: any, context?: any) => any;
+    transformFn?: (value: any) => any;
+    (value: any): any;
+}
+export interface ValidationField {
+    path: string;
+    validators: ValidatorFunction[];
+    transforms: TransformFunction[];
+}
+/**
+ * Execute validation for single field
+ */
+export declare function validateField(field: ValidationField, value: any, context: ValidationContext, options?: {
+    abortEarly?: boolean;
+}): ValidationResult;
+/**
+ * Batch validation for multiple fields
+ */
+export declare function validateBatch(fields: ValidationField[], values: any, options?: {
+    abortEarly?: boolean;
+    abortEarlyOnEachField?: boolean;
+}): ValidationResult;
+/**
+ * Parse field (validation + transform)
+ */
+export declare function parseField(field: ValidationField, value: any, context: ValidationContext, options?: {
+    abortEarly?: boolean;
+}): ParseResult;
+/**
+ * Batch parse multiple fields
+ */
+export declare function parseBatch(fields: ValidationField[], values: any, options?: {
+    abortEarly?: boolean;
+    abortEarlyOnEachField?: boolean;
+}): ParseResult;
+/**
+ * Apply transform (logic duplicated across all files)
+ */
+export declare function applyTransforms(transforms: TransformFunction[], value: any, context: ValidationContext): any;
+/**
+ * Hoisted validation (for high-speed validation)
+ */
+export declare function validateHoisted(field: ValidationField, value: any, allValues: any, abortEarlyOnEachField?: boolean, arrayContext?: import("../../plugin/types").ArrayContext): {
+    valid: boolean;
+    errorIndices?: number[];
+};
+/**
+ * Rebuild errors (for hoisted validation)
+ */
+export declare function reconstructErrors(field: ValidationField, errorIndices: number[], value: any, allValues: any, arrayContext?: import("../../plugin/types").ArrayContext): ValidationError[];
+/**
+ * ValidationEngine interface for compatibility
+ */
+export interface ValidationEngine {
+    validateField: typeof validateField;
+    validateBatch: typeof validateBatch;
+    parseField: typeof parseField;
+    parseBatch: typeof parseBatch;
+    applyTransforms: typeof applyTransforms;
+    validateHoisted: typeof validateHoisted;
+    reconstructErrors: typeof reconstructErrors;
+}
+/**
+ * 共有エンジンインスタンス取得
+ */
+export declare function getValidationEngine(): ValidationEngine;
+/**
+ * Create new engine instance (for testing)
+ */
+export declare function createValidationEngine(): ValidationEngine;

package/dist/core/optimization/execution-strategy-selector.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Execution Strategy Selector (Refactored)
+ * Uses integrated StrategyFactory - eliminates duplicate logic
+ *
+ * Before: 84 lines with strategy analysis duplication
+ * After: ~25 lines using unified core systems
+ */
+import { StrategyAnalysis } from './core/strategy-factory';
+/**
+ * Determine execution strategy for all fields (simplified)
+ * Delegates duplicated strategy analysis logic to StrategyFactory
+ */
+export declare function selectOptimalStrategies(fieldDefinitions: Array<{
+    path: string;
+    builderFunction: Function;
+}>, plugins: Record<string, any>): Map<string, StrategyAnalysis>;
+/**
+ * Group fields by strategy (simplified)
+ */
+export declare function groupByStrategy(strategies: Map<string, StrategyAnalysis>): {
+    fastFields: string[];
+    slowFields: string[];
+};

package/dist/core/optimization/unified-validator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Unified Validator - Integrates meaningless Fast/Slow separation
+ *
+ * User feedback: validateFast and validateSlow don't need separate function names
+ * Since the caller uses the same interface, they should be unified
+ *
+ * Before: FastValidator + SlowValidator = 519 lines
+ * After: UnifiedValidator = ~80 lines (85% reduction)
+ */
+interface ValidationResult {
+    readonly valid: boolean;
+    readonly errors: Array<{
+        readonly path: string;
+        readonly code: string;
+        readonly message: string;
+    }>;
+}
+interface ParseResult {
+    readonly valid: boolean;
+    readonly data?: any;
+    readonly errors: Array<{
+        readonly path: string;
+        readonly code: string;
+        readonly message: string;
+    }>;
+}
+export interface UnifiedValidator {
+    validate(value: any, rootData: any, options?: {
+        abortEarlyOnEachField?: boolean;
+    }): ValidationResult;
+    parse(value: any, rootData: any, options?: {
+        abortEarlyOnEachField?: boolean;
+    }): ParseResult;
+    accessor?: (obj: any) => any;
+}
+type ExecutionStrategy = "definition_order" | "fast_separated";
+/**
+ * Create unified validator
+ * Fast/Slow differences are internal implementation only, external interface is unified
+ */
+export declare function createUnifiedValidator(fieldDef: {
+    path: string;
+    builderFunction: Function;
+}, plugins: Record<string, any>, strategy?: ExecutionStrategy, accessor?: (obj: any) => any): UnifiedValidator;
+export {};

package/dist/core/plugin/__tests__/test-utils.d.ts

@@ -0,0 +1 @@
+export { createMockReporter, createMockContext } from '../testUtils';

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

@@ -0,0 +1,37 @@
+/**
+ * @luq-plugin
+ * @name arrayContains
+ * @category array
+ * @description Validates that an array contains at least one item matching the specified schema or value
+ * @allowedTypes ["array"]
+ * @example
+ * ```typescript
+ * // Contains specific value
+ * const validator = Builder()
+ *   .use(arrayContainsPlugin)
+ *   .for<{ tags: string[] }>()
+ *   .v("tags", (b) => b.array.contains("important"))
+ *   .build();
+ *
+ * // Contains matching schema
+ * builder.v("items", b => b.array.contains({
+ *   validator: (value) => typeof value === 'number' && value > 10,
+ *   message: "Array must contain at least one number greater than 10"
+ * }))
+ * ```
+ * @params
+ * - schema: any | { validator: (value: any) => boolean, message?: string } - Value or validation schema
+ * @returns Validation function that checks if array contains matching item
+ * @since 0.1.0-alpha
+ */
+import type { JSONSchema7 } from "json-schema";
+export interface ContainsSchema {
+    validator: (value: any) => boolean;
+    message?: string;
+}
+export declare const arrayContainsPlugin: import("../..").TypedPlugin<"arrayContains", "contains", (schema: any | ContainsSchema | JSONSchema7) => {
+    check: (value: any[]) => boolean;
+    code: string;
+    getErrorMessage: (value: any[], path: string) => any;
+    params: any[];
+}, readonly ["array"], "validator", "standard">;

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

@@ -0,0 +1,42 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name arrayIncludes
+ * @category standard
+ * @description Validates that an array contains a specific required element
+ * @allowedTypes ["array"]
+ * @example
+ * ```typescript
+ * // Basic usage - check if array contains specific item
+ * const validator = Builder()
+ *   .use(arrayIncludesPlugin)
+ *   .for<UserData>()
+ *   .v("roles", (b) => b.array.includes("admin"))
+ *   .v("permissions", (b) => b.array.includes("read"))
+ *   .build();
+ *
+ * // Multiple required items
+ * builder.v("features", b => b.array
+ *   .includes("core")
+ *   .includes("api")
+ * )
+ * ```
+ * @params
+ * - expected: any - The element that must be present in the array
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if array contains the expected element
+ * @customError
+ * ```typescript
+ * .includes("admin", {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must include "${params.expected}" (current: [${value.join(", ")}])`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const arrayIncludesPlugin: import("../..").TypedPlugin<"arrayIncludes", "includes", <TElement = any>(element: TElement, options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (ValidationOptions<{}> | TElement)[];
+}, readonly ["array"], "validator", "arrayElement">;

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

@@ -0,0 +1,43 @@
+import { ValidationOptions, MessageContext } from "./types";
+export interface ArrayMaxLengthContext extends MessageContext {
+    max: number;
+    actual: number;
+}
+/**
+ * @luq-plugin
+ * @name arrayMaxLength
+ * @category standard
+ * @description Validates that an array does not exceed the specified maximum number of elements
+ * @allowedTypes ["array"]
+ * @example
+ * ```typescript
+ * // Basic usage - set maximum array length
+ * const validator = Builder()
+ *   .use(arrayMaxLengthPlugin)
+ *   .for<FormData>()
+ *   .v("tags", (b) => b.array.maxLength(10))
+ *   .v("attachments", (b) => b.array.maxLength(5))
+ *   .build();
+ *
+ * // Limit file uploads with min and max
+ * builder.v("files", b => b.array.minLength(1).maxLength(3))
+ * ```
+ * @params
+ * - maxLength: number - Maximum number of elements allowed
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if array length does not exceed maximum
+ * @customError
+ * ```typescript
+ * .maxLength(5, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} can have at most ${params.maxLength} items (current: ${value.length})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const arrayMaxLengthPlugin: import("../..").TypedPlugin<"arrayMaxLength", "maxLength", (maxLength: number, options?: ValidationOptions<ArrayMaxLengthContext>) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | ValidationOptions<ArrayMaxLengthContext>)[];
+}, readonly ["array"], "validator", "standard">;

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

@@ -0,0 +1,43 @@
+import { ValidationOptions, MessageContext } from "./types";
+export interface ArrayMinLengthContext extends MessageContext {
+    min: number;
+    actual: number;
+}
+/**
+ * @luq-plugin
+ * @name arrayMinLength
+ * @category standard
+ * @description Validates that an array has at least the specified minimum number of elements
+ * @allowedTypes ["array"]
+ * @example
+ * ```typescript
+ * // Basic usage - set minimum array length
+ * const validator = Builder()
+ *   .use(arrayMinLengthPlugin)
+ *   .for<FormData>()
+ *   .v("tags", (b) => b.array.minLength(1))
+ *   .v("items", (b) => b.array.minLength(3))
+ *   .build();
+ *
+ * // Ensure non-empty array
+ * builder.v("selectedOptions", b => b.array.required().minLength(1))
+ * ```
+ * @params
+ * - minLength: number - Minimum number of elements required
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if array length is at least the minimum
+ * @customError
+ * ```typescript
+ * .minLength(3, {
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must have at least ${params.minLength} items (current: ${value.length})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const arrayMinLengthPlugin: import("../..").TypedPlugin<"arrayMinLength", "minLength", (minLength: number, options?: ValidationOptions<ArrayMinLengthContext>) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: (number | ValidationOptions<ArrayMinLengthContext>)[];
+}, readonly ["array"], "validator", "standard">;

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

@@ -0,0 +1,41 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name arrayUnique
+ * @category standard
+ * @description Validates that all elements in an array are unique (no duplicates)
+ * @allowedTypes ["array"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensures all array elements are unique
+ * const validator = Builder()
+ *   .use(arrayUniquePlugin)
+ *   .for<FormData>()
+ *   .v("emails", (b) => b.array.unique())
+ *   .v("userIds", (b) => b.array.required().unique())
+ *   .build();
+ *
+ * // For tags or categories
+ * builder.v("tags", b => b.array.unique().minLength(1).maxLength(10))
+ *
+ * // Combining with other array validations
+ * builder.v("productCodes", b => b.array.unique().includes("PRIMARY"))
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if all array elements are unique
+ * @customError
+ * ```typescript
+ * .unique({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} contains duplicate values`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const arrayUniquePlugin: import("../..").TypedPlugin<"arrayUnique", "unique", (options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: ValidationOptions<{}>[];
+}, readonly ["array"], "validator", "standard">;

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

@@ -0,0 +1,41 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name booleanFalsy
+ * @category standard
+ * @description Validates that a boolean value is exactly false
+ * @allowedTypes ["boolean"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensures value is exactly false
+ * const validator = Builder()
+ *   .use(booleanFalsyPlugin)
+ *   .for<Settings>()
+ *   .v("isActive", (b) => b.boolean.falsy())
+ *   .v("debugMode", (b) => b.boolean.required().falsy())
+ *   .build();
+ *
+ * // Privacy settings
+ * builder.v("shareData", b => b.boolean.falsy())
+ *
+ * // Security flags
+ * builder.v("allowExternalAccess", b => b.boolean.required().falsy())
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true if value is exactly false
+ * @customError
+ * ```typescript
+ * .falsy({
+ *   messageFactory: ({ path, value }) =>
+ *     `${path} must be set to false (current: ${value})`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const booleanFalsyPlugin: import("../..").TypedPlugin<"booleanFalsy", "falsy", (options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: ValidationOptions<{}>[];
+}, readonly ["boolean"], "validator", "standard">;

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

@@ -0,0 +1,38 @@
+import { ValidationOptions } from "./types";
+/**
+ * @luq-plugin
+ * @name booleanTruthy
+ * @category standard
+ * @description Validates that a boolean value is exactly true
+ * @allowedTypes ["boolean"]
+ * @example
+ * ```typescript
+ * // Basic usage - ensure value is exactly true
+ * const validator = Builder()
+ *   .use(booleanTruthyPlugin)
+ *   .for<FormData>()
+ *   .v("isActive", (b) => b.boolean.truthy())
+ *   .v("termsAccepted", (b) => b.boolean.required().truthy())
+ *   .build();
+ *
+ * // For consent checkboxes
+ * builder.v("agreeToTerms", b => b.boolean.required().truthy())
+ * ```
+ * @params
+ * - options?: { messageFactory?: (context: MessageContext) => string } - Optional configuration
+ * @returns Validation function that returns true only if value is exactly true
+ * @customError
+ * ```typescript
+ * .truthy({
+ *   messageFactory: ({ path }) =>
+ *     `${path} must be checked/accepted`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const booleanTruthyPlugin: import("../..").TypedPlugin<"booleanTruthy", "truthy", (options?: ValidationOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: ValidationOptions<{}>[];
+}, readonly ["boolean"], "validator", "standard">;

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

@@ -0,0 +1,58 @@
+import { ValidationOptions } from "./types";
+type CompareFn = (value: any, targetValue: any) => boolean;
+interface CompareFieldOptions extends ValidationOptions {
+    compareFn?: CompareFn;
+}
+/**
+ * @luq-plugin
+ * @name compareField
+ * @category standard
+ * @description Validates a field's value by comparing it with another field's value using a custom comparison function
+ * @allowedTypes ["string", "number", "boolean", "date", "object", "array", "null", "undefined"]
+ * @example
+ * ```typescript
+ * // Default usage - strict equality
+ * const validator = Builder()
+ *   .use(compareFieldPlugin)
+ *   .for<SignupForm>()
+ *   .v("password", (b) => b.string.required().min(8))
+ *   .v("confirmPassword", (b) => b.string.required().compareField("password"))
+ *   .build();
+ *
+ * // Custom comparison - date before
+ * builder.v("endDate", (b) => b.string.datetime().compareField("startDate", {
+ *   compareFn: (endDate, startDate) => new Date(endDate) > new Date(startDate),
+ *   messageFactory: () => "End date must be after start date"
+ * }))
+ *
+ * // Number comparison
+ * builder.v("maxValue", (b) => b.number.compareField("minValue", {
+ *   compareFn: (max, min) => max >= min,
+ *   messageFactory: () => "Max value must be greater than or equal to min value"
+ * }))
+ * ```
+ * @params
+ * - fieldPath: string - Path to the field to compare against (supports dot notation)
+ * - options?: { compareFn?: (value, targetValue) => boolean, messageFactory?: (context) => string } - Optional configuration
+ * @returns Validation function that returns true if comparison passes
+ * @customError
+ * ```typescript
+ * .compareField("startDate", {
+ *   compareFn: (end, start) => new Date(end) > new Date(start),
+ *   messageFactory: ({ path, value, params }) =>
+ *     `${path} must be after ${params.fieldPath}`
+ * })
+ * ```
+ * @since 0.1.0-alpha
+ */
+export declare const compareFieldPlugin: import("../..").TypedPlugin<"compareField", "compareField", (fieldPath: string, options?: CompareFieldOptions) => {
+    check: (value: any, allValues?: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string, allValues?: any) => string;
+    params: (string | CompareFieldOptions)[];
+    fieldReference: {
+        fieldPath: string;
+        compareFn: CompareFn;
+    };
+}, readonly ["string", "number", "boolean", "date", "object", "array", "tuple", "union"], "validator", "fieldReference">;
+export {};

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

@@ -0,0 +1,24 @@
+import { ValidationOptions } from "./types";
+import { JSONSchema7 } from "json-schema";
+export interface ConditionalSchemaOptions extends ValidationOptions {
+    ifSchema: JSONSchema7;
+    thenSchema?: JSONSchema7;
+    elseSchema?: JSONSchema7;
+    validator?: (value: any, schema: JSONSchema7) => boolean;
+}
+/**
+ * Conditional Schema Plugin (if/then/else)
+ *
+ * Handles JSON Schema Draft-07 conditional validation
+ * @luq-plugin
+ * @name conditionalSchema
+ * @category advanced
+ * @description Validates based on if/then/else conditions
+ * @allowedTypes ["object"]
+ */
+export declare const conditionalSchemaPlugin: import("../..").TypedPlugin<"conditionalSchema", "conditionalSchema", (options: ConditionalSchemaOptions) => {
+    check: (value: any) => boolean;
+    code: string;
+    getErrorMessage: (value: any, path: string) => string;
+    params: ConditionalSchemaOptions[];
+}, readonly ["object"], "validator", "standard">;