import type { Widget } from "../../api/binder/BaseBinderBuilder";
import type { CmdBinder } from "../../api/binder/CmdBinder";
import type { InteractionBinder } from "../../api/binder/InteractionBinder";
import type { InteractionCmdBinder } from "../../api/binder/InteractionCmdBinder";
import type { When, WhenType } from "../../api/binder/When";
import type { Binding } from "../../api/binding/Binding";
import type { BindingsObserver } from "../../api/binding/BindingsObserver";
import type { RuleName, Severity } from "../../api/checker/Checker";
import type { Command } from "../../api/command/Command";
import type { Interaction, InteractionDataType } from "../../api/interaction/Interaction";
import type { Logger } from "../../api/logging/Logger";
import type { LogLevel } from "../../api/logging/LogLevel";
import type { UndoHistoryBase } from "../../api/undo/UndoHistoryBase";
export declare abstract class Binder<C extends Command, I extends Interaction<D>, A, D extends object = InteractionDataType<I>> implements CmdBinder<C>, InteractionBinder<I, A, D>, InteractionCmdBinder<C, I, A, D> {
    protected firstFn?: (c: C, i: D, acc: A) => void;
    protected produceFn?: (i: D | undefined) => C;
    protected widgets: ReadonlyArray<unknown>;
    protected dynamicNodes: ReadonlyArray<Node>;
    protected usingFn?: () => I;
    protected hadEffectsFn?: (c: C, i: D, acc: A) => void;
    protected hadNoEffectFn?: (c: C, i: D, acc: A) => void;
    protected cannotExecFn?: (c: C, i: D, acc: A) => void;
    protected endFn?: (c: C, i: D, acc: A) => void;
    protected onErrFn?: (ex: unknown) => void;
    protected logLevels: ReadonlyArray<LogLevel>;
    protected stopPropagation: boolean;
    protected prevDefault: boolean;
    protected bindingName: string | undefined;
    protected observer: BindingsObserver | undefined;
    protected undoHistory: UndoHistoryBase;
    protected logger: Logger;
    protected whenFnArray: Array<When<D, A>>;
    protected firstFnArray: Array<(c: C, i: D, acc: A) => void>;
    protected endFnArray: Array<(c: C, i: D, acc: A) => void>;
    protected hadEffectsFnArray: Array<(c: C, i: D, acc: A) => void>;
    protected hadNoEffectFnArray: Array<(c: C, i: D, acc: A) => void>;
    protected cannotExecFnArray: Array<(c: C, i: D, acc: A) => void>;
    protected onErrFnArray: Array<(ex: unknown) => void>;
    protected accInit: A | undefined;
    protected linterRules: Map<RuleName, Severity>;
    protected constructor(undoHistory: UndoHistoryBase, logger: Logger, observer?: BindingsObserver, binder?: Partial<Binder<C, I, A, D>>, acc?: A);
    protected abstract duplicate(): Binder<C, I, A, D>;
    protected copyFnArrays(): void;
    on<W>(widget: ReadonlyArray<Widget<W>> | Widget<W>, ...widgets: ReadonlyArray<Widget<W>>): Binder<C, I, A, D>;
    onDynamic(node: Widget<Node>): Binder<C, I, A, D>;
    first(fn: (c: C, i: D, acc: A) => void): Binder<C, I, A, D>;
    when(fn: (i: D, acc: Readonly<A>) => boolean, mode?: WhenType): Binder<C, I, A, D>;
    ifHadEffects(fn: (c: C, i: D, acc: A) => void): Binder<C, I, A, D>;
    ifHadNoEffect(fn: (c: C, i: D, acc: A) => void): Binder<C, I, A, D>;
    ifCannotExecute(fn: (c: C, i: D, acc: A) => void): Binder<C, I, A, D>;
    end(fn: (c: C, i: D, acc: A) => void): Binder<C, I, A, D>;
    log(...level: ReadonlyArray<LogLevel>): Binder<C, I, A, D>;
    stopImmediatePropagation(): Binder<C, I, A, D>;
    preventDefault(): Binder<C, I, A, D>;
    catch(fn: (ex: unknown) => void): Binder<C, I, A, D>;
    name(name: string): Binder<C, I, A, D>;
    configureRules(ruleName: RuleName, severity: Severity): Binder<C, I, A, D>;
    usingInteraction<I2 extends Interaction<D2>, A2, D2 extends object = InteractionDataType<I2>>(fn: () => I2): Binder<C, I2, A2, D2>;
    toProduce<C2 extends Command>(fn: (i: D) => C2): Binder<C2, I, A, D>;
    toProduceAnon(fn: () => void): Binder<Command, I, A, D>;
    abstract bind(): Binding<C, I, A, D>;
}