import { Instance as Instance$1 } from '@popperjs/core';

declare class EditionSession {
    private instance;
    private type;
    private renderer;
    private markup;
    constructor(instance: Instance, type: FlyterType<any>, renderer: FlyterRenderer<any>);
    getType(): FlyterType<any>;
    getInstance(): Instance;
    getRenderer(): FlyterRenderer<any>;
    getFlyterElement(): HTMLElement;
    getSessionMarkup(): HTMLElement;
    initialize(): Promise<void>;
    openEdition(): Promise<void>;
    cancel(): Promise<void>;
    closeSession(): Promise<void>;
    submit(): Promise<void>;
    private setRendererLoading;
    private getElement;
}

type anyConfigObject = {
    [key: string]: any;
};
type DeepPartial<T> = {
    [P in keyof T]?: DeepPartial<T[P]> | T[P];
};
type TypeConstructor<C extends anyConfigObject = anyConfigObject> = new (getSession: () => EditionSession, config: C) => FlyterType<C>;
type RendererConstructor = new (getSession: () => EditionSession, config: anyConfigObject) => FlyterRenderer<anyConfigObject>;
type rendererData = {
    rendererConfig: anyConfigObject;
    renderer: RendererConstructor;
};
type typeData = {
    typeConfig: anyConfigObject;
    type: TypeConstructor;
};
declare abstract class FlyterType<Config> {
    protected getSession: () => EditionSession;
    protected config: Config;
    constructor(getSession: () => EditionSession, config: Config);
    getTypeConfig(): Config;
    abstract init(): Promise<any> | any;
    abstract show(container: HTMLElement, value: any): Promise<any> | any;
    abstract getCurrentValue(): any;
    abstract getReadableValue(val: any): Promise<string> | string;
    abstract disable(status: boolean): any;
    abstract onDestroy(): Promise<any> | any;
}
declare abstract class FlyterRenderer<Config> {
    protected getSession: () => EditionSession;
    protected config: Config;
    constructor(getSession: () => EditionSession, config: Config);
    getRendererConfig(): Config;
    abstract getMarkup(): HTMLElement | null;
    abstract init(): Promise<any> | any;
    abstract error(error: Error): any;
    abstract show(markup: HTMLElement): Promise<any> | any;
    abstract hide(): Promise<any> | any;
    abstract destroy(): Promise<any> | any;
    abstract setLoading(loading: boolean): any;
}

declare class Instance {
    private domTarget;
    private config;
    private typeGetter;
    private rendererGetter;
    private session;
    flyterElement: HTMLElement;
    private value;
    private loading;
    private disabled;
    private listener;
    private keyListener;
    private configResolver;
    constructor(domTarget: HTMLElement, config: Config, typeGetter: (name: string) => typeData, rendererGetter: (name: string) => rendererData);
    getDomTarget(): HTMLElement;
    getConfig(key: string, callback?: boolean): any;
    getRawConfig(): Config;
    updateConfig(config: DeepPartial<Config>): void;
    getCurrentSession(): EditionSession | null;
    getFlyterElement(): HTMLElement;
    open(): Promise<EditionSession | undefined>;
    close(): Promise<void>;
    getValue(): any;
    setValue(val: any): Promise<void>;
    refresh(): Promise<void>;
    buildStandardReadableValue(val: any | null): Promise<string>;
    deleteSession(): void;
    disable(): Promise<void>;
    enable(): Promise<void>;
    destroy(): Promise<void>;
    buildType(): FlyterType<anyConfigObject>;
    buildRenderer(): FlyterRenderer<anyConfigObject>;
    private attachKeyEvent;
    private createSession;
    private setInstanceLoading;
    private buildFlyterTarget;
}

interface Config {
    themes: anyConfigObject;
    trigger: "click" | "hover" | "none" | ((instance: Instance) => "click" | "hover" | "none");
    submitOnEnter: boolean | ((instance: Instance) => boolean);
    triggerOnTarget: boolean | ((instance: Instance) => boolean);
    emptyValue: any | ((instance: Instance) => any);
    initialValue: any | ((instance: Instance) => any);
    emptyValueDisplay: string | ((instance: Instance) => string);
    valueFormatter: (value: any, instance: Instance) => string | Promise<string>;
    onOpen: (instance: Instance) => Promise<any> | any;
    onDisabled: (instance: Instance) => Promise<any> | any;
    onEnabled: (Instance: Instance) => Promise<any> | any;
    onClose: (instance: Instance) => Promise<any> | any;
    onDestroy: (instance: Instance) => Promise<any> | any;
    onSubmit: (value: any, instance: Instance) => Promise<any> | any;
    onLoading: (status: boolean, instance: Instance) => void;
    onRendererLoading: (status: boolean, instance: Instance) => any;
    onError: (error: Error, instance: Instance) => Promise<any> | any;
    onCancel: (instance: Instance) => Promise<any> | any;
    validate: (value: any, instance: Instance) => Promise<Error | boolean> | Error | boolean;
    server: {
        url: string | null | ((instance: Instance) => string);
        queryParams: anyConfigObject | ((instance: Instance) => anyConfigObject);
        method: string | ((instance: Instance) => string);
        resultFormatter: (data: any, value: any) => any;
    };
    type: {
        name: string | ((instance: Instance) => string);
        config: any | ((instance: Instance) => any);
    };
    renderer: {
        name: string | ((instance: Instance) => string);
        config: any | ((instance: Instance) => any);
    };
    okButton: {
        enabled: boolean | ((instance: Instance) => boolean);
        text: string | ((instance: Instance) => string);
    };
    cancelButton: {
        enabled: boolean | ((instance: Instance) => boolean);
        text: string | ((instance: Instance) => string);
    };
    template: {
        edit: string | ((instance: Instance) => string);
        buttons: string | ((instance: Instance) => string);
        read: string | ((instance: Instance) => string);
        loading: string | ((instance: Instance) => string);
    };
}

declare class ManyInstance {
    private instances;
    constructor(instances: Instance[]);
    getInstances(): Instance[];
    updateAllConfig(config: DeepPartial<Config>): void;
    getCurrentSessions(): EditionSession[];
    openAll(): Promise<any[]>;
    closeAll(): Promise<any[]>;
    refreshAll(): Promise<any[]>;
    destroyAll(): Promise<any[]>;
    enableAll(): Promise<void>;
    disableAll(): void;
    private asyncBatch;
    private batch;
}

declare class Flyter {
    private renderers;
    private types;
    private themes;
    registerRenderer(name: string, renderer: any, baseRendererConfig: anyConfigObject): void;
    registerType<C extends anyConfigObject>(name: string, type: TypeConstructor<C>, baseTypeConfig: C): void;
    registerTheme(name: string, theme: any, baseThemeConfig: anyConfigObject): void;
    attach(target: HTMLElement | string | HTMLElement[] | NodeList, givenConfig?: DeepPartial<Config> | string): Instance | ManyInstance;
    private attachMultiple;
    private buildInstance;
    private getType;
    private getRenderer;
    private resolveThemeConfig;
}

type Theme = {
    renderers?: {
        [rendererName: string]: anyConfigObject;
    };
    types?: {
        [typeName: string]: anyConfigObject;
    };
    config?: DeepPartial<Config>;
};

interface BootstrapThemeConfig {
    size: "xs" | "md" | "lg" | "xl" | "sm";
    okBtntnTheme: string;
    cancelBtnTheme: string;
    spinnerTheme: string;
    inline: boolean;
}

declare const parseTemplate: (markup: string | HTMLElement | (() => string)) => HTMLElement;

type valOrAsync$1<T> = T | ((renderer: PopupRenderer) => T) | ((renderer: PopupRenderer) => Promise<T>);
type PopupConfigType = {
    popper: (...args: any[]) => Instance$1 | Instance$1;
    popperConfig: valOrAsync$1<{
        placement: string | anyConfigObject;
    }>;
    transitionDuration: valOrAsync$1<number>;
    title: valOrAsync$1<string | null>;
    closeOnClickOutside: valOrAsync$1<boolean>;
    popupTemplate: valOrAsync$1<string>;
    popupContainer: valOrAsync$1<string | HTMLElement>;
    popupClass: valOrAsync$1<string>;
    onInit: ((renderer: PopupRenderer) => any) | ((renderer: PopupRenderer) => Promise<any>);
    onShow: ((renderer: PopupRenderer) => any) | ((renderer: PopupRenderer) => Promise<any>);
    onHide: ((renderer: PopupRenderer) => any) | ((renderer: PopupRenderer) => Promise<any>);
};
declare class PopupRenderer extends FlyterRenderer<PopupConfigType> {
    private loading;
    private markup;
    private transitionDuration;
    private closeOnClickOutside;
    private listener;
    private popperInstance;
    getPopperInstance(): Instance$1 | null;
    getMarkup(): HTMLElement | null;
    init(): Promise<void>;
    error(error: Error): void;
    show(markup: HTMLElement): Promise<void>;
    hide(): Promise<void>;
    destroy(): Promise<void>;
    setLoading(loading: boolean): void;
    private getElement;
    private getPopupContainer;
}

type valOrAsync<T> = T | ((renderer: InlineRenderer) => T) | ((renderer: InlineRenderer) => Promise<T>);
type InlineConfigType = {
    closeOnClickOutside: valOrAsync<boolean>;
    inlineTemplate: valOrAsync<string>;
    containerClass: valOrAsync<string>;
    onInit: ((renderer: InlineRenderer) => any) | ((renderer: InlineRenderer) => Promise<any>);
    onShow: ((renderer: InlineRenderer) => any) | ((renderer: InlineRenderer) => Promise<any>);
    onHide: ((renderer: InlineRenderer) => any) | ((renderer: InlineRenderer) => Promise<any>);
};
declare class InlineRenderer extends FlyterRenderer<InlineConfigType> {
    private loading;
    private markup;
    private closeOnClickOutside;
    private listener;
    private originDisplay;
    getMarkup(): HTMLElement | null;
    init(): Promise<void>;
    error(error: Error): void;
    show(markup: HTMLElement): Promise<void>;
    hide(): Promise<void>;
    destroy(): Promise<void>;
    setLoading(loading: boolean): void;
    private getElement;
}

type TextTypeConfig = {
    class: string;
    type: string;
    attributes: string;
    treatEmptyAsNull: boolean;
};
declare class TextType extends FlyterType<TextTypeConfig> {
    private textElement;
    init(): void;
    show(container: HTMLElement, value: any): void;
    getCurrentValue(): any;
    getReadableValue(val: any): any;
    disable(status: boolean): void;
    onDestroy(): void;
    private getTemplate;
}

type DataSource = Array<{
    value: any;
    label: string;
}>;
interface BaseChoiceConfig {
    dataSource: DataSource | (() => DataSource) | (() => Promise<DataSource>);
    class: string;
}
declare abstract class BaseChoiceType<T extends BaseChoiceConfig, U extends HTMLElement> extends FlyterType<T> {
    protected dataSource: DataSource;
    protected markup: U;
    init(): Promise<void>;
    show(container: HTMLElement, value: any): void;
    disable(status: boolean): void;
    onDestroy(): void;
    abstract setValue(value: any): any;
    abstract getTemplate(): string;
}

interface SelectTypeConfig extends BaseChoiceConfig {
    multiple: boolean;
    displaySeparator: string;
    showEmptyValue: boolean;
}
declare class SelectType extends BaseChoiceType<SelectTypeConfig, HTMLSelectElement> {
    setValue(value: any): void;
    getCurrentValue(): any;
    getReadableValue(value: any[]): string;
    getTemplate(): string;
}

interface RadioTypeConfig extends BaseChoiceConfig {
    labelClass: string;
    radioClass: string;
    inputContainerClass: string;
}
declare class RadioType extends BaseChoiceType<RadioTypeConfig, HTMLDivElement> {
    setValue(value: any): void;
    getCurrentValue(): any;
    getReadableValue(value: any[]): string;
    getTemplate(): string;
    getRadios(): HTMLInputElement[];
}

interface CheckboxTypeConfig extends BaseChoiceConfig {
    displaySeparator: string;
    checkboxClass: string;
    labelClass: string;
    inputContainerClass: string;
}
declare class CheckboxType extends BaseChoiceType<CheckboxTypeConfig, HTMLDivElement> {
    setValue(value: any): void;
    getCurrentValue(): any;
    getReadableValue(value: any | any[]): string;
    getTemplate(): string;
    getCheckbox(): HTMLInputElement[];
}

declare const flyter: Flyter;
declare const withBootstrapTheme: (config?: DeepPartial<BootstrapThemeConfig>) => void;
declare const withPopupRenderer: (config?: DeepPartial<PopupConfigType>) => void;
declare const withInlineRenderer: (config?: DeepPartial<InlineConfigType>) => void;
declare const withTextType: () => void;
declare const withSelectType: () => void;
declare const withCheckboxType: () => void;
declare const withRadioType: () => void;

export { CheckboxType, type CheckboxTypeConfig, Flyter as FlyterBuilder, FlyterRenderer, FlyterType, InlineRenderer, Instance, ManyInstance, PopupRenderer, RadioType, type RadioTypeConfig, SelectType, type SelectTypeConfig, TextType, type TextTypeConfig, type Theme, flyter as default, parseTemplate, withBootstrapTheme, withCheckboxType, withInlineRenderer, withPopupRenderer, withRadioType, withSelectType, withTextType };