import { BlockLanguages } from '../models/block-languages';
export declare class InputHandler {
    #private;
    get label(): object;
    get value(): any;
    set value(val: any);
    input: (event: Event, options?: InputHandler.PropOpts) => void;
    constructor(el: InputHandler.Element);
    create(path: string, el: any): void;
    get<T>(path: string, options?: InputHandler.GetOpts): T;
    prop(path: string, options?: InputHandler.PropOpts): {
        label: string | undefined;
        name: string;
        placeholder: string | undefined;
        value: any;
        onInput: (e: Event) => void;
    };
    set<T>(path: string, value: T, options?: InputHandler.SetOpts): T;
    t<T>(path: string, options?: InputHandler.GetOpts): T;
    setLanguage(languages: BlockLanguages, language: string): void;
    tryGet<T>(path: string, options?: InputHandler.GetOpts): T | undefined;
    private emit;
    private getLocalePath;
    private update;
}
export declare namespace InputHandler {
    type Element = (HTMLElement & {
        value: object;
        label: object;
    }) | (HTMLElement & {
        template: object;
    });
    interface GetOpts {
        localize?: boolean;
        obj?: object;
        transform?: InputHandler.Transform;
        type?: 'label' | 'placeholder' | 'value';
    }
    type Prop = ReturnType<InputHandler['prop']>;
    interface PropOpts {
        default?: () => any;
        label?: object;
        localize?: boolean;
        on?: InputHandler.SideEffect;
        transform?: InputHandler.Transform;
    }
    interface SetOpts {
        emit?: boolean;
        localize?: boolean;
    }
    interface SideEffect {
        (value: any, path: string): void;
    }
    interface Transform<A = any, B = any> {
        path?: string;
        get: TransformFunc<A, B>;
        set: TransformFunc<B, A>;
    }
    interface TransformFunc<A = any, B = any> {
        (value: A): B;
    }
}
