import { Subject } from 'rxjs';
import { ActionButton } from '../external-types/actionButton';
import { CallAPIActionButton } from '../external-types/callAPIActionButton';
import { EmitEventActionButton } from '../external-types/emitEventActionButton';
import { SectionElement } from '../external-types/sectionElement';
import { ViewStructure } from '../external-types/viewStructure';
export type PageBuilderForm = {
    head: {
        title: {
            mainTitle: string;
            subTitle: string;
            position: 'center' | 'left' | 'right';
        };
    };
    body: {
        helpers?: PageBuilderHelpers[];
        form: {
            formVariables: {
                [key: string]: any;
            };
            formTemplate: any[];
            data: {
                [key: string]: any;
            };
            isValidationOFF?: boolean;
            guiOption: {
                cardClass?: string;
                formOrientation?: 'horizontal' | 'vertical';
                cardLite?: boolean;
            };
            customCSS: string;
            remoteItemsFetchRequests?: {
                formFieldName: string;
                domainName: string;
                valueName: string;
            }[];
            debug?: boolean;
            isValidationForced?: boolean;
        };
        buttons?: PageBuilderDefaultButton[];
    };
    vigilantOpts?: {
        afterInit?: {
            checkVigilant?: boolean;
        };
        afterCommit?: {
            checkVigilant?: boolean;
        };
    };
    tourNames?: string[];
};
export type PageBuilderTabset = {
    head: {
        title: {
            mainTitle: string;
            subTitle: string;
            position: 'center' | 'left' | 'right';
        };
        breadcrumbs?: PageBuilderDefaultBreadcrumb[];
    };
    body: {
        helpersSmall?: PageBuilderHelpers[] | undefined;
        helpers?: PageBuilderHelpers[] | undefined;
        tabset: GenericTabset;
    };
    vigilantOpts?: {
        afterInit?: {
            checkVigilant?: boolean;
        };
        afterCommit?: {
            checkVigilant?: boolean;
        };
    };
    tourNames?: string[];
    extra?: {
        pageSize?: 'small' | 'medium' | 'large' | 'default';
    };
};
export type PageBuilderSimpleView = {
    head: {
        title: {
            mainTitle: string;
            subTitle: string;
            position: 'center' | 'left' | 'right';
        };
        breadcrumbs?: PageBuilderDefaultBreadcrumb[];
        header?: {
            logo?: PageBuilderDefaultImage | undefined;
            buttons?: PageBuilderDefaultButton[];
        };
    };
    body: {
        helpers?: PageBuilderHelpers[] | undefined;
        helpersSmall?: PageBuilderHelpers[] | undefined;
        content?: {
            html?: string;
        };
        buttons?: PageBuilderDefaultButton[];
        innersButtons?: PageBuilderInnerButton[];
    };
    vigilantOpts?: {
        afterInit?: {
            checkVigilant?: boolean;
        };
        afterCommit?: {
            checkVigilant?: boolean;
        };
    };
    eventsOpts?: {
        afterInit?: EmitEventActionButton[];
        afterCommit?: EmitEventActionButton[];
    };
    tourNames?: string[];
    remoteLoading?: {
        hasRemoteLoading: boolean;
        remoteLoadingParams: RemoteLoadingParams;
    };
};
export type PageBuilderCRUD = {
    head: {
        title?: {
            mainTitle: string;
            subTitle: string;
            position: 'center' | 'left' | 'right';
        };
        breadcrumbs: PageBuilderDefaultBreadcrumb[];
    };
    body: {
        helpers?: PageBuilderHelpers[];
        toolbar?: PageBuilderToolbarButtons;
        crud: {
            data: {
                dataset: any[];
                offset: number;
                limit: number;
                total: number;
                order: any;
            };
            columns: any[];
            filtri?: any[];
            defaultSearchFieldName?: string;
            options: {
                isServerSide: boolean;
                hasFiltriSettings?: boolean;
                hideCheckboxColumn?: boolean;
            };
        };
    };
    vigilantOpts?: {
        afterInit?: {
            checkVigilant?: boolean;
        };
        afterCommit?: {
            checkVigilant?: boolean;
        };
    };
    tourNames?: string[];
};
export type PageBuilderCRUDV2 = {
    head: {
        title?: {
            mainTitle: string;
            subTitle: string;
            position: 'center' | 'left' | 'right';
        };
        breadcrumbs: PageBuilderDefaultBreadcrumb[];
    } | undefined;
    body: {
        helpers?: PageBuilderHelpers[];
        toolbar?: PageBuilderToolbarButtonsV2;
        crud: {
            data: {
                dataset: any[];
                offset: number;
                limit: number;
                total: number;
                order: any;
            };
            columns: any[];
            filtri?: any[];
            defaultSearchFieldName: string;
            options: {
                isServerSide: boolean;
                hasFiltriSettings?: boolean;
                hideCheckboxColumn?: boolean;
                filtersOptions?: {
                    defaultDeactivateLabel?: string;
                };
            };
            rowButtons?: PageBuilderDefaultButton[];
        };
    };
    vigilantOpts?: {
        afterInit?: {
            checkVigilant?: boolean;
        };
        afterCommit?: {
            checkVigilant?: boolean;
        };
    };
    tourNames?: string[];
};
export type PageBuilderCardView = {
    head: {
        title: {
            mainTitle: string;
            subTitle: string;
            position: 'center' | 'left' | 'right';
        };
        breadcrumbs?: PageBuilderDefaultBreadcrumb[];
    };
    body: {
        helpers?: PageBuilderHelpers[];
        helpersSmall?: PageBuilderHelpers[];
        cards: GenericCardData[];
        buttons?: PageBuilderDefaultButton[];
    };
    vigilantOpts?: {
        afterInit?: {
            checkVigilant?: boolean;
        };
        afterCommit?: {
            checkVigilant?: boolean;
        };
    };
    tourNames?: string[];
    extra?: {
        pageSize?: 'small' | 'medium' | 'large' | 'default';
        position?: 'center' | 'left' | 'right';
    } | undefined;
};
export type PageBuilderDashboard = {
    body: {
        helpers?: PageBuilderHelpers[];
        infoArea?: PageBuilderInfoArea;
        toolsArea?: PageBuilderToolsArea;
        lastUsedArea?: PageBuilderLastUsedArea;
    };
};
export type PageBuilderCatalog = {
    head?: {
        breadcrumbs?: PageBuilderDefaultBreadcrumb[];
        header?: {
            logo?: PageBuilderDefaultImage;
            buttons?: PageBuilderDefaultButton[];
        };
        banner?: PageBuilderDefaultBanner;
        title: {
            mainTitle: string;
            subTitle: string;
            position: 'center' | 'left' | 'right';
        };
    };
    body?: {
        helpers?: PageBuilderHelpers[];
        catalogue: {
            data: {
                dataset: PageBuilderDefaultCardImage[];
                offset: number;
                limit: number;
                total: number;
                order: any;
            };
            searchBox?: PageBuilderSearchbox;
        };
    };
};
export type PageBuilderDefaultBanner = {
    image?: PageBuilderDefaultImage;
    description?: string;
    button?: PageBuilderDefaultButton;
};
export type PageBuilderDefaultCardImage = {
    image?: PageBuilderDefaultImage;
    title?: string;
    description?: string;
    help?: {
        text?: string;
        html?: string;
    };
    button?: PageBuilderDefaultButton;
};
export type PageBuilderDefaultImage = {
    url?: string;
    base64?: string;
    size?: 'default' | 'small' | 'smaller';
    customSize?: {
        width?: string;
        height?: string;
    };
    customStyleClass?: string;
};
export type PageBuilderInfoArea = {
    title: string;
    infos: {
        title: string;
        description: string;
        button?: PageBuilderDefaultButton;
        imageURL?: string;
    }[];
};
export type PageBuilderToolsArea = {
    title: string;
    tools: {
        title: string;
        description: string;
        icon?: string;
        isDisabled?: boolean;
        button: PageBuilderDefaultButton;
    }[];
};
export type PageBuilderLastUsedArea = {
    title: string;
    lasts: {
        title: string;
        subtitle?: string;
        description?: string;
        button: PageBuilderDefaultButton;
    }[];
};
export type PageBuilderDefaultButton = ActionButton;
export type PageBuilderToolbarButtons = {
    buttons?: PageBuilderDefaultButton[];
    dropdown?: PageBuilderDropdownButton;
    searchBox?: PageBuilderSearchbox;
    exportDropdown?: PageBuilderDropdownButton;
    filterToggle?: {
        isDisabled?: boolean;
    };
};
export type PageBuilderToolbarButtonsV2 = {
    buttons?: PageBuilderDefaultButton[];
    dropdown?: PageBuilderDropdownButton;
    singleSelectionDropdown?: PageBuilderDropdownButton;
    multipleSelectionDropdown?: PageBuilderDropdownButton;
    searchBox?: PageBuilderSearchbox;
    exportDropdown?: PageBuilderDropdownButton;
    filterToggle?: {
        isDisabled?: boolean;
    };
};
export type PageBuilderDropdownButton = {
    labelDropdown?: {
        label: string;
        icon: string;
        customStyleClass?: string;
        help?: {
            text?: string;
            html?: string;
        };
    };
    buttonDropdown?: PageBuilderDefaultButton;
    list: PageBuilderDefaultButton[];
    iconOnly?: boolean;
    size?: 'default' | 'small' | 'smaller';
    dropdownPosition?: 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'topLeft' | 'topCenter' | 'topRight';
};
export type PageBuilderHelpers = {
    type: 'alert' | 'info' | 'warning' | 'success';
    text?: string;
    html?: string;
    button?: PageBuilderDefaultButton;
    active?: boolean;
    help?: {
        label?: string;
        text?: string;
        html?: string;
    };
};
export type PageBuilderModalResponse = {
    refreshFather: boolean;
    committed: boolean;
    keepOpen?: boolean;
    error?: {
        messages: string[];
    };
    nextOperation?: any;
};
export type PageBuilderDrawerResponse = {
    refreshFather: boolean;
    committed: boolean;
    keepOpen?: boolean;
    error?: {
        messages: string[];
    };
    nextOperation?: any;
};
export type PageBuilderDefaultInput = {
    viewId: string;
    structure?: PageBuilderForm | PageBuilderTabset | any;
    parameters?: string[];
    view?: ViewStructure;
    passiveRefresh?: boolean;
};
export type PageBuilderInstanceParameters = {
    moduleId?: string;
    componentName?: string;
    componentInstanceParameters: PageBuilderDefaultInput;
};
export type PageBuilderSearchbox = {
    placeholder?: string;
    onValChangesSearch?: boolean;
    help?: {
        text?: string;
        html?: string;
    };
};
export type PageBuilderDefaultBreadcrumb = {
    label: string;
    icon?: string;
    routerLink?: any;
    historyBack?: boolean;
    queryParams?: any;
    tooltip?: {
        text?: string;
        html?: string;
    };
};
export type PageBuilderInnerButton = {
    htmlElementId: string;
    button: PageBuilderDefaultButton;
};
export type PageBuilderPaginatedHelpers = {
    helpers: PageBuilderDefaultHelper[];
    size?: 'default' | 'small' | 'smaller';
    pageSize?: number;
};
export type PageBuilderDefaultHelper = {
    type: 'danger' | 'info' | 'warning' | 'success';
    text?: string;
    html?: string;
    button?: PageBuilderDefaultButton;
    active?: boolean;
    help?: {
        label?: string;
        text?: string;
        html?: string;
    };
    style?: 'outline' | 'default';
    size?: 'default' | 'small' | 'smaller';
    customIcon?: string;
};
/** PB COMPONENTS  */
export type PbDefaultButtonOutput = {
    btn: PageBuilderDefaultButton;
    sub?: Subject<PbOutputSub>;
};
export type PbOutputSub = {
    loading?: boolean;
    message?: string;
};
export type PbDefaultSearchboxOutput = {
    value: string;
    inputSub?: Subject<string>;
};
/** PageBuilderService */
export type ActionButtonResponse = {
    needRefresh?: boolean;
    result: boolean;
    response?: any;
    rawResponse?: any;
    eventToHandle?: EmitEventActionButton;
    closeModal?: boolean;
    closeDrawer?: boolean;
    landingUrl?: string;
    error?: {
        messages?: string[];
    };
    extra?: any;
};
/** COMPONENTS */
export type RemoteLoadingParams = {
    interval: number;
    timeout?: number;
    lastCallResponse?: 'OK' | 'KO' | 'PENDING';
    callParams: RemoteLoadingCallParams;
    indeterminate?: boolean;
    percent: number;
};
export type RemoteLoadingCallParams = {
    apiService: string;
    apiMethod: string;
    params?: string[];
    query?: {
        [key: string]: string;
    };
};
export type GenericTabset = {
    tabs: GenericTabsetTabs[];
    position: 'top' | 'right' | 'bottom' | 'left';
    shortcut?: {
        selectionLabel: string;
        displayPrefix: boolean;
    };
    hideTabs?: boolean;
    firstActiveTabIndex?: {
        index: number;
    };
};
export type GenericTabsetTabs = {
    title?: string;
    id: string;
    icon?: string;
    badge?: string;
    badgeTitle?: string;
    disabled?: boolean;
    disabledMessage?: string;
    content: {
        type: 'view' | 'section-content' | 'action-button';
        data: {
            view: PageBuilderDefaultInput;
            actionButton: ActionButton;
            section: any;
        };
    };
};
export type GenericCardData = SectionElement;
/** TOUR */
export type TourStep = {
    id: string;
    attachTo: {
        element: string;
        on: 'left' | 'top' | 'bottom' | 'right';
    };
    beforeShowPromise?: Promise<any>;
    buttons?: {
        classes?: string;
        text?: string;
        action?: () => void;
    }[];
    cancelIcon?: {
        enabled?: boolean;
    };
    classes?: string;
    highlightClass?: string;
    scrollTo?: boolean;
    title?: string;
    text?: string | string[] | any;
    when?: {
        show?: () => void;
        hide?: () => void;
    };
};
export type Tour = {
    name: string;
    steps: {
        showCancel?: boolean;
        title: string;
        text?: string | string[] | any;
        attachTo: {
            HTMLClassElement: string;
            on?: 'left' | 'top' | 'bottom' | 'right';
        };
    }[];
};
export type ApiCallParams = {
    viewId: string;
    apiService: string;
    params: any[];
};
export type PbCardData = SectionElement;
export type PbRemoteLoadingParams = {
    interval: number;
    timeout?: number;
    lastCallResponse?: 'OK' | 'KO' | 'PENDING';
    callParams: PbRemoteLoadingCallParams;
    indeterminate?: boolean;
    percent: number;
};
export type PbRemoteLoadingCallParams = {
    apiService: string;
    apiMethod: string;
    params?: string[];
    query?: {
        [key: string]: string;
    };
};
export type ListCardOptions = {
    searchBarOptions: ListCardDataSearchBarOptions;
    showSearchBar: boolean;
    counterLabel: string;
};
export type ListCardDataSearchBarOptions = {
    placeholder: string;
    minChar: number;
    noElemFoundMessage: string;
};
export type PbTagFilter = {
    label: string;
    value: string;
};
export type PbPaginatedPageOptions = {
    searchBarOptions: {
        minChar: number;
        noElemFoundMessage: string;
        placeholder: string;
    };
    showSearchBar: boolean;
    pageIndex: number;
    pageSize: number;
    itemButtonDisplayMode?: 'dropdown' | 'row';
    showTagsFilters?: boolean;
    tagsFilters?: PbTagFilter[];
};
export interface PbChecklistDocument extends SectionElement {
    docStatus: boolean;
    extraData: {
        label: string;
        value: string;
    }[];
    dropdownButton?: PageBuilderDropdownButton;
}
export declare interface PageBuilder {
    /**
     * Dato in input un PageBuilderDefaultInput invoca il PageBuilderService per avere la struttura
     * della page
     * @param value
     */
    initInputData(value: PageBuilderDefaultInput): void;
    /**
     * Invocato dal metodo initInputData permette di gestire la risposta del PageBuilderService
     * @param res
     */
    handleResStructure(res: any): void;
    /**
     * Permette di inizializzare la sub utilizzata per il caricamento
     */
    initLoadingSub(): void;
    /**
     * Permette di fermare il caricamento
     */
    stopLoading(): void;
    /**
     * Permette di richiamare initInputData per aggiornare la page
     */
    refreshPage(): void;
    /**
     * Permette di inizializzare i listener disponibili per la pagina
     */
    pageListener(): void;
    /**
     * Accetta in input un evento PbDefaultButtonOutput e permette di gestire il btn
     * contenuto nell'evento
     * @param event
     */
    btnHandler(event: PbDefaultButtonOutput): void;
    /**
     * Accetta in input una res ottenuta da un action button e l'eventuale subject
     * utilizzata per il loading. Il metodo gestisce la risposta e la subject.
     * @param res
     * @param subLoading
     */
    handlerActionButtonResFn(res: ActionButtonResponse, subLoading: Subject<PbOutputSub>): void;
    /**
     * Dato in input una ActionButtonResponse effettua dei controlli nel caso la page sia istanziata
     * come modale
     * @param res
     */
    checkModalClose(res: ActionButtonResponse): void;
    /**
     * Metodo che permette di disiscriversi dai listener avviati dal costruttore
     */
    standardOnDestroyFn(): void;
    /**
     * Dato in input una ActionButtonResponse permette di gestire la res di tipo need-refresh
     * @param res
     */
    actionButtonResNeedRefreshFn(res: ActionButtonResponse): void;
    /**
     * Dato in input una ActionButtonResponse permette di gestire la res di tipo close-modal
     * @param res
     */
    actionButtonResCloseModalFn(res: ActionButtonResponse): void;
    /**
     * Dato in input una ActionButtonResponse permette di gestire la res di tipo event-to-handle
     * @param res
     */
    actionButtonResEventToHandleFn(res: ActionButtonResponse): void;
}
export type FileParams = {
    fileId?: string;
    context?: string;
    filetype?: string;
    referenceId?: string;
};
export type DefaultResponseApiCaller = {
    needRefresh?: boolean;
    result: boolean;
    response?: any;
    rawResponse?: any;
    error?: {
        messages?: string[];
    };
};
export type CallApiInput = CallAPIActionButton;