import { AnimType } from "../types/enums/AnimType.js";
import { ArrayName } from "../types/enums/ArrayName.js";
import { Renderer } from "../types/enums/Renderer.js";
import { Type } from "../types/enums/Type.js";
import { Properties } from "../types/properties/components.js";
import { BindingItem, ButtonMapping, Control, ModificationItem, VariableItem, Variables } from "../types/properties/value.js";
import { Animation } from "./Animation.js";
import { AnimationKeyframe } from "./AnimationKeyframe.js";
import { Class } from "./Class.js";
import util from "node:util";
import { FactoryManager } from "./Factory.js";
interface ExtendUI {
    name: string;
    namespace: string;
    toString(): string;
}
type ChildInput<C extends UI<Type, Renderer | null>> = {
    child: C;
    properties?: C extends UI<infer T, infer K> ? Partial<Properties<T, K>> : never;
    name?: string;
    callback?: (name: string, parent: UI<Type, Renderer | null>) => void;
};
export declare class UI<T extends Type, K extends Renderer | null = null> extends Class {
    type?: T | undefined;
    readonly path: string;
    readonly name: string;
    readonly namespace: string;
    readonly extend?: UI<Type, Renderer | null> | ExtendUI;
    readonly extendable: boolean;
    protected readonly controls: Map<string, [UI<Type, Renderer | null>, Properties<Type, Renderer | null>]>;
    protected readonly bindings: BindingItem[];
    protected readonly variables: VariableItem[];
    protected readonly buttonMappings: ButtonMapping[];
    protected readonly anims: (Animation<AnimType> | AnimationKeyframe<AnimType>)[];
    protected readonly extendType?: Type;
    protected factory?: FactoryManager;
    protected properties: Properties<T, K>;
    protected bindCache: Map<string, unknown>;
    constructor(type?: T | undefined, name?: string, namespace?: string, path?: string, allowObfuscate?: boolean);
    /**
     * Set properties for this element
     * @param properties
     * @returns
     */
    setProperties(properties: Properties<T, K>): this;
    setFactory(factory: FactoryManager): this;
    /**
     * Bind data (coming from the code) to this UI element to use.
     * @param bindings
     * @returns
     */
    addBindings(...bindings: BindingItem[]): this;
    /**
     * Changes variables values if conditions are met.
     * @param variables
     * @returns
     */
    addVariables(variables: Variables): this;
    /**
     * Add button mappings for this element
     * @param mappings
     * @returns
     */
    addButtonMappings(...mappings: ButtonMapping[]): this;
    /**
     * Children of the UI element.
     * @param child
     * @param properties
     * @param name
     * @returns
     */
    addChild<T extends Type, K extends Renderer | null>(child: UI<T, K>, properties?: Properties<T, K>, name?: string, callback?: (name: string, parent: UI<T, K>) => void): this;
    addChilds<UIs extends readonly UI<Type, Renderer | null>[]>(...childs: {
        [K in keyof UIs]: ChildInput<UIs[K]>;
    }): this;
    addAnimations(...anims: (Animation<AnimType> | AnimationKeyframe<AnimType>)[]): this;
    /**
     * Return a extend of this element
     * @param properties
     * @param name
     * @param namespace
     * @returns
     */
    createExtends(properties?: Properties<T, K>, name?: string, namespace?: string): UI<T, K>;
    toString(): Control;
    protected toJsonUI(): any;
    protected toJSON(): any;
    protected [util.inspect.custom]($: any, opts: any): string;
}
export declare class ModifyUI<T extends Type = Type.PANEL, S extends string = string> extends UI<T, null> {
    private isClearBinding;
    private isClearVariables;
    private isClearControls;
    private isClearAnims;
    private isClearButtonMappings;
    protected modifications: ModificationItem[];
    constructor(namespace: string, name: string, path: string);
    clearArray(arrayName: ArrayName): this;
    /**
     * Remove all variables of this modfy element
     * @returns
     */
    clearVariables(): this;
    /**
     * Allows to modify the UI elements from resource packs below this one
     * @returns
     */
    addModifications(...modifications: ModificationItem[]): this;
    insertBackChild<T extends Type, K extends Renderer | null>(child: UI<T, K>, properties?: Properties<T, K>, name?: string): this;
    insertFrontChild<T extends Type, K extends Renderer | null>(child: UI<T, K>, properties?: Properties<T, K>, name?: string): this;
    insertAfterChild<T extends Type, K extends Renderer | null>(where: S, child: UI<T, K>, properties?: Properties<T, K>, name?: string): this;
    insertBeforeChild<T extends Type, K extends Renderer | null>(where: S, child: UI<T, K>, properties?: Properties<T, K>, name?: string): this;
    insertChild<T extends Type, K extends Renderer | null>(child: UI<T, K>, properties?: Properties<T, K>, name?: string): this;
    replaceChild<T extends Type, K extends Renderer | null>(where: S, child: UI<T, K>, properties?: Properties<T, K>): this;
    /**
     * Remove a child of this element
     * @param name
     * @returns
     */
    removeChild(name: S): this;
    insertBackBindings(...bindings: BindingItem[]): this;
    insertFrontBindings(...bindings: BindingItem[]): this;
    insertBindings(...bindings: BindingItem[]): this;
    /**
     * Remove a binding of this element
     * @param binding
     */
    removeBinding(binding: BindingItem): this;
    insertBackButtonMappings(...buttonMappings: ButtonMapping[]): this;
    insertFrontButtonMappings(...buttonMappings: ButtonMapping[]): this;
    insertButtonMappings(...buttonMappings: ButtonMapping[]): this;
    /**
     * Remove a button mapping of this element
     * @param buttonMapping
     * @returns
     */
    removeButtonMapping(buttonMapping: ButtonMapping): this;
    protected toJsonUIModify(): any;
    protected toJSON(): any;
    protected [util.inspect.custom]($: any, opts: any): string;
}
export {};