import type { FieldRuntimeController } from './field-runtime-controller.js';
import type { FormDependencies } from './form-dependency.js';
import type { AltEditorLiteError } from '../core/alt-editor-lite-error.js';
import type { EditorValues } from '../core/editor-values.js';
import type { FieldConfig } from '../fields/field-config.js';
import type { MaybePromise } from '../fields/field-value.js';
import type { ManagedFieldController } from '../fields/managed-field-controller.js';
/** Configured resources required to validate and apply one field patch. */
export interface DependencyFieldBinding<TFormValues extends object> {
    readonly config: Readonly<FieldConfig<TFormValues>>;
    readonly controller: ManagedFieldController<TFormValues>;
    readonly runtime: FieldRuntimeController<TFormValues>;
}
export interface FormDependencyControllerArguments<TFormValues extends object> {
    readonly dependencies: Readonly<FormDependencies<TFormValues>>;
    readonly fields: ReadonlyMap<string, DependencyFieldBinding<TFormValues>>;
    readonly lifecycleSignal: AbortSignal;
    readonly normalizeError: (error: unknown) => AltEditorLiteError;
    readonly onErrorChange: (sourcePath: string, error: AltEditorLiteError | undefined) => void;
    readonly isSourceAvailable?: (sourcePath: string) => boolean;
    readonly applyValue?: (targetPath: string, binding: DependencyFieldBinding<TFormValues>, value: unknown) => MaybePromise<void>;
    readonly afterApplyPatch?: (application: Readonly<DependencyPatchApplication<TFormValues>>) => MaybePromise<void>;
}
/** Information exposed after one validated dependency patch is applied. */
export interface DependencyPatchApplication<TFormValues extends object> {
    readonly isCurrent: () => boolean;
    readonly binding: DependencyFieldBinding<TFormValues>;
    readonly targetPath: string;
    readonly hasOptions: boolean;
    readonly hasValue: boolean;
}
/** Resolves, validates, and applies declarative field state. */
export declare class FormDependencyController<TFormValues extends object> {
    private readonly arguments_;
    private readonly resolverBySource;
    private readonly activeRequestBySource;
    private readonly pendingBySource;
    private readonly revisionBySource;
    private readonly latestErrorBySource;
    private patchApplicationTail;
    private isDestroyed;
    constructor(arguments_: FormDependencyControllerArguments<TFormValues>);
    /** Resolves every source against one shared initial values snapshot. */
    initialize(values: Readonly<EditorValues<TFormValues>>): Promise<void>;
    /** Resolves and applies the dependency associated with one user-edited source. */
    handleUserChange(sourcePath: string, values: Readonly<EditorValues<TFormValues>>, parentSignal: AbortSignal): Promise<void>;
    /** Waits for currently owned resolver requests and patch application. */
    waitForCurrent(): Promise<void>;
    errors(): ReadonlyMap<string, AltEditorLiteError>;
    abortSource(sourcePath: string): void;
    destroy(): void;
    private startResolution;
    private invokeResolver;
    private isCurrent;
    private mergeInitialResults;
    private validateResult;
    private applyPatches;
    private queuePatches;
    private recordError;
    private clearError;
}