@tempots/beatui 0.16.0 → 0.18.0

package/dist/types/components/json-schema/controls/presence-toggle.d.ts

@@ -0,0 +1,12 @@
+import { Renderable } from '@tempots/dom';
+import type { Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Presence toggle for optional properties.
+ * Shows a toggle that controls whether the property key exists in the parent object.
+ */
+export declare function PresenceToggle<T>({ ctx, controller, content, }: {
+    ctx: SchemaContext;
+    controller: Controller<T>;
+    content: Renderable;
+}): Renderable;

package/dist/types/components/json-schema/controls/schema-banners.d.ts

@@ -0,0 +1,14 @@
+import { Renderable } from '@tempots/dom';
+import type { SchemaConflict, NotViolation } from '../schema-context';
+/**
+ * Banner component for displaying schema conflicts
+ */
+export declare function SchemaConflictsBanner({ conflicts, }: {
+    conflicts: readonly SchemaConflict[];
+}): Renderable;
+/**
+ * Banner component for displaying schema violations
+ */
+export declare function NotViolationsBanner({ violations, }: {
+    violations: readonly NotViolation[];
+}): Renderable;

package/dist/types/components/json-schema/controls/schema-wrapper.d.ts

@@ -0,0 +1,7 @@
+import { Renderable } from '@tempots/dom';
+import type { Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Wraps content with schema issues banners and presence toggle if needed
+ */
+export declare function WithSchemaIssues<T>(ctx: SchemaContext, content: Renderable, controller?: Controller<T>): Renderable;

package/dist/types/components/json-schema/controls/shared-utils.d.ts

@@ -0,0 +1,16 @@
+import type { JSONSchema } from '../schema-context';
+import type { InputWrapperOptions } from '../../form';
+/**
+ * Convert schema definition to input wrapper options
+ */
+export declare function definitionToInputWrapperOptions({ ctx, }: {
+    ctx: import('../schema-context').SchemaContext;
+}): Partial<InputWrapperOptions>;
+/**
+ * Create placeholder value from schema definition
+ */
+export declare function makePlaceholder<T>(definition: JSONSchema, converter: (value: unknown) => T): T | undefined;
+/**
+ * Convert multipleOf to integer step for integer inputs
+ */
+export declare function integerMultipleOf(multipleOf?: number): number;

package/dist/types/components/json-schema/controls/string-control.d.ts

@@ -0,0 +1,10 @@
+import { Renderable } from '@tempots/dom';
+import { type Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for string schemas
+ */
+export declare function JSONSchemaString({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<string | undefined>;
+}): Renderable;

package/dist/types/components/json-schema/controls/type-utils.d.ts

@@ -0,0 +1,27 @@
+import type { JSONSchema } from '../schema-context';
+export type JSONTypeName = 'string' | 'number' | 'integer' | 'object' | 'array' | 'boolean' | 'null';
+/**
+ * Detect the JSON type name for a value
+ */
+export declare function detectTypeName(v: unknown, union: JSONTypeName[]): JSONTypeName | null;
+/**
+ * Try to convert a value to a target type
+ */
+export declare function tryConvert(value: unknown, target: JSONTypeName): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+};
+/**
+ * Get default cleared value for a type
+ */
+export declare function defaultClearedValue(target: JSONTypeName): unknown;
+/**
+ * Extract x:ui configuration from schema with proper typing
+ */
+export declare function getXUI(def: JSONSchema): {
+    unionDefault?: JSONTypeName;
+    confirmBranchChange?: boolean;
+    selector?: 'segmented' | 'select';
+};

package/dist/types/components/json-schema/controls/union-control.d.ts

@@ -0,0 +1,10 @@
+import { Renderable } from '@tempots/dom';
+import { type Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for union type schemas
+ */
+export declare function JSONSchemaUnion<T>({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<T>;
+}): Renderable;

package/dist/types/components/json-schema/controls.d.ts

@@ -0,0 +1,11 @@
+export { JSONSchemaAny } from './controls/any-control';
+export { JSONSchemaEnum, JSONSchemaConst } from './controls/enum-const-controls';
+export { JSONSchemaNumber, JSONSchemaInteger } from './controls/number-controls';
+export { JSONSchemaString } from './controls/string-control';
+export { JSONSchemaBoolean } from './controls/boolean-control';
+export { JSONSchemaNull } from './controls/null-control';
+export { JSONSchemaArray } from './controls/array-control';
+export { JSONSchemaObject } from './controls/object-control';
+export { JSONSchemaUnion } from './controls/union-control';
+export { JSONSchemaAnyOf, JSONSchemaOneOf, JSONSchemaAllOf, } from './controls/composition-controls';
+export { JSONSchemaGenericControl, JSONSchemaControl, } from './controls/generic-control';

package/dist/types/components/json-schema/discriminator/discriminator-utils.d.ts

@@ -0,0 +1,57 @@
+import type { JSONSchema } from '../schema-context';
+/**
+ * OpenAPI discriminator configuration
+ */
+export interface OpenAPIDiscriminator {
+    /** The name of the property in the payload that will hold the discriminator value */
+    propertyName: string;
+    /** An object to hold mappings between payload values and schema names or references */
+    mapping?: Record<string, string>;
+}
+/**
+ * BeatUI discriminator configuration (fallback)
+ */
+export interface BeatUIDiscriminator {
+    /** The property name to use for discrimination */
+    key: string;
+    /** Optional mapping of values to schema indices */
+    mapping?: Record<string, number>;
+}
+/**
+ * Extract discriminator configuration from a oneOf schema
+ */
+export declare function getDiscriminatorConfig(schema: JSONSchema): {
+    discriminator: OpenAPIDiscriminator | BeatUIDiscriminator | null;
+    type: 'openapi' | 'beatui' | null;
+};
+/**
+ * Determine which oneOf branch should be selected based on discriminator value
+ */
+export declare function selectOneOfBranch(oneOfSchemas: JSONSchema[], discriminatorConfig: {
+    discriminator: OpenAPIDiscriminator | BeatUIDiscriminator | null;
+    type: 'openapi' | 'beatui' | null;
+}, currentValue: unknown): number | null;
+/**
+ * Get the discriminator property name from configuration
+ */
+export declare function getDiscriminatorPropertyName(discriminatorConfig: {
+    discriminator: OpenAPIDiscriminator | BeatUIDiscriminator | null;
+    type: 'openapi' | 'beatui' | null;
+}): string | null;
+/**
+ * Create a discriminator value for a specific oneOf branch
+ */
+export declare function createDiscriminatorValue(oneOfSchemas: JSONSchema[], branchIndex: number, discriminatorConfig: {
+    discriminator: OpenAPIDiscriminator | BeatUIDiscriminator | null;
+    type: 'openapi' | 'beatui' | null;
+}): Record<string, unknown> | null;
+/**
+ * Validate that a oneOf schema is properly configured for discriminator usage
+ */
+export declare function validateDiscriminatorConfiguration(oneOfSchemas: JSONSchema[], discriminatorConfig: {
+    discriminator: OpenAPIDiscriminator | BeatUIDiscriminator | null;
+    type: 'openapi' | 'beatui' | null;
+}): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/types/components/json-schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ajv-utils';
+export * from './schema-context';
+export * from './controls';
+export * from './json-schema-form';
+export * from './validator';

package/dist/types/components/json-schema/json-schema-form.d.ts

@@ -0,0 +1,79 @@
+import { type SchemaObject } from 'ajv';
+import { Value, Renderable } from '@tempots/dom';
+import { Controller, ControllerValidation } from '../form';
+/**
+ * External reference resolver function type.
+ * Called when the form encounters external $ref URIs that need to be resolved.
+ *
+ * @param ids - Array of external schema IDs that need to be resolved
+ * @returns Promise resolving to array of schema objects with matching $id properties
+ *
+ * @example
+ * ```typescript
+ * const refResolver = async (ids: string[]) => {
+ *   const schemas = await Promise.all(
+ *     ids.map(id => fetch(`/schemas/${id}`).then(r => r.json()))
+ *   )
+ *   return schemas
+ * }
+ * ```
+ */
+export type ExternalRefResolver = (ids: ReadonlyArray<string>) => Promise<ReadonlyArray<SchemaObject>>;
+/**
+ * Configuration options for JSONSchemaForm external reference resolution.
+ */
+export interface JSONSchemaFormExternalOptions {
+    /**
+     * Pre-bundled external schemas to register with AJV before compilation.
+     * These schemas should have $id properties and will be available for $ref resolution.
+     *
+     * @example
+     * ```typescript
+     * const externalSchemas = [
+     *   { $id: 'https://example.com/address', type: 'object', properties: { ... } },
+     *   { $id: 'https://example.com/person', type: 'object', properties: { ... } }
+     * ]
+     * ```
+     */
+    externalSchemas?: ReadonlyArray<SchemaObject>;
+    /**
+     * Dynamic resolver for external $ref URIs not found in externalSchemas.
+     * Called when the form encounters external references during schema compilation.
+     * The resolver should fetch and return schemas with matching $id properties.
+     *
+     * @example
+     * ```typescript
+     * const refResolver = async (ids: string[]) => {
+     *   // Fetch schemas from API, filesystem, or other sources
+     *   return await fetchSchemasById(ids)
+     * }
+     * ```
+     */
+    refResolver?: ExternalRefResolver;
+    /**
+     * Controls automatic sanitization of form data to remove properties
+     * not allowed by the schema (e.g., when additionalProperties: false).
+     *
+     * - 'all': Remove all additional properties
+     * - 'failing': Remove only properties that cause validation failures
+     * - false: No automatic sanitization (default)
+     */
+    sanitizeAdditional?: 'all' | 'failing' | false;
+}
+/**
+ * Props for the JSONSchemaForm component.
+ */
+export interface JSONSchemaFormProps<T> extends JSONSchemaFormExternalOptions {
+    /** The root JSON Schema to render as a form */
+    schema: SchemaObject;
+    /** Reactive value containing the form data */
+    initialValue: Value<T>;
+    /** Validation behavior */
+    validationMode?: 'onSubmit' | 'continuous' | 'touchedOrSubmit';
+    validateDebounceMs?: number;
+}
+export declare function JSONSchemaForm<T>({ schema, initialValue, externalSchemas, refResolver, sanitizeAdditional, validationMode, validateDebounceMs, }: JSONSchemaFormProps<T>, fn: ({ Form, controller, setStatus, }: {
+    Form: Renderable;
+    controller: Controller<T>;
+    setStatus: (result: ControllerValidation) => void;
+}) => Renderable): Renderable;

package/dist/types/components/json-schema/oneof-branch-detection.d.ts

@@ -0,0 +1,35 @@
+import type { Ajv } from 'ajv';
+import type { JSONSchemaDefinition, SchemaContext } from './schema-context';
+/**
+ * Result of oneOf branch detection
+ */
+export interface OneOfBranchDetectionResult {
+    /** Index of the matching branch, or -1 if no single match */
+    matchingBranch: number;
+    /** Array of all branches that validate against the current value */
+    validBranches: number[];
+    /** Whether multiple branches match (ambiguous for oneOf) */
+    isAmbiguous: boolean;
+    /** Whether no branches match */
+    hasNoMatch: boolean;
+}
+/**
+ * Detect which oneOf branch(es) the current value matches.
+ * This works with both inline schemas and $ref schemas by resolving references first.
+ *
+ * @param ctx - Schema context containing oneOf definition
+ * @param value - Current value to test against branches
+ * @param ajv - AJV instance for validation (optional, falls back to heuristics)
+ * @returns Branch detection result
+ */
+export declare function detectOneOfBranch(ctx: SchemaContext, value: unknown, ajv?: Ajv): OneOfBranchDetectionResult;
+/**
+ * Get a human-readable label for a oneOf branch.
+ * Prioritizes title, then discriminator values, then type, then fallback.
+ */
+export declare function getOneOfBranchLabel(branch: JSONSchemaDefinition, index: number, fallback?: string): string;
+/**
+ * Auto-select the best oneOf branch for a given value.
+ * Returns the branch index, or -1 if no clear choice can be made.
+ */
+export declare function autoSelectOneOfBranch(ctx: SchemaContext, value: unknown, ajv?: Ajv): number;

package/dist/types/components/json-schema/ref-utils.d.ts

@@ -0,0 +1,18 @@
+import type { JSONSchema, JSONSchemaDefinition } from './schema-context';
+import type { Ajv } from 'ajv';
+export declare function clearRefCaches(): void;
+/**
+ * Resolve a $ref within the provided definition against the given root schema.
+ * - Supports in-document JSON Pointer refs only (e.g. "#/$defs/Address").
+ * - If siblings are present next to $ref, they are shallow-merged over the resolved target.
+ * - Resolves chains of $ref until a non-$ref definition is reached or a cycle is detected.
+ * - Memoized per root/definition identity.
+ */
+export declare function resolveRef(def: JSONSchema, root: JSONSchemaDefinition): JSONSchema;
+/**
+ * Resolve a $ref in a schema definition, supporting both in-document ("#...")
+ * and external references (e.g., "https://example.com/schema#/$defs/Thing") when
+ * an AJV instance is available. Sibling keywords next to $ref are shallow-merged
+ * over the resolved target at each step. Cycles are detected and resolution stops.
+ */
+export declare function resolveAnyRef(def: JSONSchema, root: JSONSchemaDefinition, ajv: Ajv | undefined): JSONSchema;

package/dist/types/components/json-schema/schema-context.d.ts

@@ -0,0 +1,185 @@
+import type Ajv from 'ajv';
+export type JSONSchemaType = 'null' | 'boolean' | 'object' | 'array' | 'number' | 'string' | 'integer';
+export type JSONSchemaDefinition = JSONSchema | boolean;
+export interface JSONSchema {
+    $id?: string;
+    $schema?: string;
+    $ref?: string;
+    $comment?: string;
+    title?: string;
+    description?: string;
+    default?: unknown;
+    examples?: unknown[];
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    deprecated?: boolean;
+    type?: JSONSchemaType | JSONSchemaType[];
+    enum?: unknown[];
+    const?: unknown;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    format?: string;
+    items?: JSONSchemaDefinition | JSONSchemaDefinition[];
+    additionalItems?: JSONSchemaDefinition;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    contains?: JSONSchemaDefinition;
+    minContains?: number;
+    maxContains?: number;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    properties?: Record<string, JSONSchemaDefinition>;
+    patternProperties?: Record<string, JSONSchemaDefinition>;
+    additionalProperties?: JSONSchemaDefinition;
+    dependencies?: Record<string, JSONSchemaDefinition | string[]>;
+    propertyNames?: JSONSchemaDefinition;
+    if?: JSONSchemaDefinition;
+    then?: JSONSchemaDefinition;
+    else?: JSONSchemaDefinition;
+    allOf?: JSONSchemaDefinition[];
+    anyOf?: JSONSchemaDefinition[];
+    oneOf?: JSONSchemaDefinition[];
+    not?: JSONSchemaDefinition;
+    dependentRequired?: Record<string, string[]>;
+    dependentSchemas?: Record<string, JSONSchemaDefinition>;
+    unevaluatedItems?: JSONSchemaDefinition;
+    unevaluatedProperties?: JSONSchemaDefinition;
+    prefixItems?: JSONSchemaDefinition[];
+    contentEncoding?: string;
+    contentMediaType?: string;
+    contentSchema?: JSONSchemaDefinition;
+    definitions?: Record<string, JSONSchemaDefinition>;
+    $defs?: Record<string, JSONSchemaDefinition>;
+    [key: string]: unknown;
+}
+export type SchemaConflict = {
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly message: string;
+    readonly conflictingValues: readonly unknown[];
+};
+export type AllOfMergeResult = {
+    readonly mergedSchema: JSONSchema;
+    readonly conflicts: readonly SchemaConflict[];
+};
+export type NotViolation = {
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly message: string;
+    readonly notSchema: JSONSchema;
+};
+export type SchemaContextOptions = {
+    schema: JSONSchemaDefinition;
+    definition: JSONSchemaDefinition;
+    horizontal: boolean;
+    path: ReadonlyArray<PropertyKey>;
+    ajv?: Ajv;
+    isPropertyRequired?: boolean;
+    suppressLabel?: boolean;
+    schemaConflicts?: readonly SchemaConflict[];
+    notViolations?: readonly NotViolation[];
+};
+export declare class SchemaContext {
+    readonly schema: JSONSchemaDefinition;
+    readonly definition: JSONSchemaDefinition;
+    readonly horizontal: boolean;
+    readonly path: ReadonlyArray<PropertyKey>;
+    readonly ajv: Ajv | undefined;
+    readonly isPropertyRequired: boolean;
+    readonly suppressLabel: boolean;
+    readonly schemaConflicts: readonly SchemaConflict[];
+    readonly notViolations: readonly NotViolation[];
+    constructor(options: SchemaContextOptions);
+    readonly with: (options: Partial<SchemaContextOptions>) => SchemaContext;
+    readonly append: (segment: PropertyKey) => SchemaContext;
+    get isRoot(): boolean;
+    get name(): string | undefined;
+    get widgetName(): string;
+    get widgetLabel(): string | undefined;
+    readonly hasRequiredProperty: (name: string) => boolean;
+    get nullable(): any;
+    get isNullable(): boolean;
+    /**
+     * Determines if this property is optional (can be absent from parent object).
+     * This is different from nullable - optional means the key can be missing,
+     * while nullable means the value can be explicitly null.
+     */
+    get isOptional(): boolean;
+    /**
+     * Determines if this property should show a presence toggle.
+     * Optional properties that are not at the root level should have presence toggles,
+     * but primitive values that allow null should use nullable controls instead.
+     */
+    get shouldShowPresenceToggle(): boolean;
+    /**
+     * Determines if this schema represents a primitive type (string, number, boolean, null).
+     */
+    get isPrimitive(): boolean;
+    /**
+     * Determines if this property is marked as readOnly.
+     */
+    get isReadOnly(): boolean;
+    /**
+     * Determines if this property is marked as writeOnly.
+     */
+    get isWriteOnly(): boolean;
+    /**
+     * Determines if this property is marked as deprecated.
+     */
+    get isDeprecated(): boolean;
+    /**
+     * Checks if readOnly should be ignored based on x:ui.ignoreReadOnly.
+     */
+    get shouldIgnoreReadOnly(): boolean;
+    /**
+     * Checks if writeOnly should be shown based on x:ui.showWriteOnly.
+     */
+    get shouldShowWriteOnly(): boolean;
+    get anyOf(): SchemaContext[] | undefined;
+    get oneOf(): SchemaContext[] | undefined;
+    get allOf(): SchemaContext[] | undefined;
+    readonly hasType: (type: JSONSchemaType) => boolean;
+    readonly hasEnumValue: (value: unknown) => boolean;
+    readonly hasConstValue: (value: unknown) => boolean;
+    get description(): string | undefined;
+    get examples(): unknown[] | undefined;
+    get default(): unknown;
+}
+/**
+ * Deep merge allOf branches into a single effective schema.
+ * - Intersects types (detects conflicts like string ∧ number)
+ * - Unions required arrays
+ * - Deep merges properties objects
+ * - Detects and reports conflicts as non-blocking schema errors
+ */
+export declare function mergeAllOf(allOfSchemas: readonly JSONSchema[], basePath?: ReadonlyArray<PropertyKey>): AllOfMergeResult;
+/**
+ * Evaluate `not` subschema against the current value using AJV.
+ * Returns a NotViolation if the value matches the disallowed schema.
+ */
+export declare function evaluateNotViolation(notSchema: JSONSchema, value: unknown, ajv: Ajv | undefined, basePath?: ReadonlyArray<PropertyKey>): NotViolation | null;
+/**
+ * Evaluate if/then/else and dependencies overlays for an object schema without
+ * mutating the base definition. Returns a new effective schema plus any merge
+ * conflicts discovered while composing overlays.
+ */
+export declare function composeEffectiveObjectSchema(baseDef: JSONSchema, value: unknown, ajv: Ajv | undefined, basePath?: ReadonlyArray<PropertyKey>): {
+    effective: JSONSchema;
+    conflicts: readonly SchemaConflict[];
+};
+/**
+ * Returns the overlay schema coming from if/then/else for the given value or
+ * null if no overlay applies or no AJV instance is available.
+ */
+export declare function evaluateIfThenElseOverlay(def: JSONSchema, value: unknown, ajv: Ajv | undefined): JSONSchema | null;
+/**
+ * Tracks which properties have been evaluated by various JSON Schema keywords.
+ * This is used to implement unevaluatedProperties semantics for 2019-09/2020-12.
+ */
+export declare function getEvaluatedProperties(schema: JSONSchema, value: Record<string, unknown> | undefined, ajv: Ajv | undefined): Set<string>;

package/dist/types/components/json-schema/validation/async-validation.d.ts

@@ -0,0 +1,113 @@
+import type { JSONSchema } from '../schema-context';
+import { Prop } from '@tempots/dom';
+import { ControllerValidation } from '@/components/form';
+/**
+ * Async validation rule configuration
+ */
+export interface AsyncValidationRule {
+    /** Unique identifier for the rule */
+    id: string;
+    /** Field path to validate */
+    field: string;
+    /** Debounce delay in milliseconds (default: 300) */
+    debounce?: number;
+    /** Validation function */
+    validate: (value: unknown, formData: unknown) => Promise<AsyncValidationResult>;
+    /** Loading message to show during validation */
+    loadingMessage?: string;
+    /** Whether to validate on blur only (default: false) */
+    validateOnBlurOnly?: boolean;
+    /** Minimum value length to trigger validation */
+    minLength?: number;
+    /** Dependencies that should trigger revalidation */
+    dependencies?: string[];
+}
+/**
+ * Result of async validation
+ */
+export interface AsyncValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Error message if validation failed */
+    message?: string;
+    /** Additional context for error reporting */
+    context?: Record<string, unknown>;
+}
+/**
+ * Async validation state
+ */
+export interface AsyncValidationState {
+    /** Whether validation is currently running */
+    isValidating: boolean;
+    /** Current validation result */
+    result: ControllerValidation;
+    /** Last validated value */
+    lastValidatedValue: unknown;
+    /** Timestamp of last validation */
+    lastValidatedAt: number;
+}
+/**
+ * Built-in async validation rules
+ */
+export declare const BUILTIN_ASYNC_RULES: {
+    /**
+     * Check if username is available (example)
+     */
+    usernameAvailable: (field: string, checkAvailability: (username: string) => Promise<boolean>, options?: {
+        minLength?: number;
+        debounce?: number;
+    }) => AsyncValidationRule;
+    /**
+     * Validate email format and check if it exists
+     */
+    emailExists: (field: string, checkExists: (email: string) => Promise<boolean>, options?: {
+        debounce?: number;
+    }) => AsyncValidationRule;
+    /**
+     * Custom API validation
+     */
+    apiValidation: (field: string, apiCall: (value: unknown, formData: unknown) => Promise<{
+        valid: boolean;
+        message?: string;
+    }>, options?: {
+        debounce?: number;
+        minLength?: number;
+        loadingMessage?: string;
+    }) => AsyncValidationRule;
+};
+/**
+ * Extract async validation rules from schema x:ui
+ */
+export declare function getAsyncValidationRules(schema: JSONSchema): AsyncValidationRule[];
+/**
+ * Async validator class that manages debouncing and state
+ */
+export declare class AsyncValidator {
+    private timeouts;
+    private validationStates;
+    private abortControllers;
+    /**
+     * Create or get validation state signal for a field
+     */
+    getValidationState(fieldId: string): Prop<AsyncValidationState>;
+    /**
+     * Validate a field with debouncing
+     */
+    validateField(rule: AsyncValidationRule, value: unknown, formData: unknown, force?: boolean): Promise<void>;
+    /**
+     * Cancel all pending validations
+     */
+    cancelAll(): void;
+    /**
+     * Get current validation results for all fields
+     */
+    getAllValidationResults(): Record<string, ControllerValidation>;
+    /**
+     * Check if any validations are currently running
+     */
+    isValidating(): boolean;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+}